The New Sudoku Players' Forum

[tarek]

Code: Select all

+-------+-------+-------+
| . . 1 | 9 . 2 | 3 . . |
| . 9 . | . . . | . 4 . |
| . . 5 | . . . | 7 . . |
+-------+-------+-------+
| 8 1 . | . . . | . 5 7 |
| 3 . . | . 4 . | . . 2 |
| . . 7 | . . . | 8 . . |
+-------+-------+-------+
| . . 8 | 7 . 6 | 1 . . |
| . . . | . . . | . . . |
| 2 . . | . 5 . | . . 8 |
+-------+-------+-------+
..19.23...9.....4...5...7..81.....573...4...2..7...8....87.61...........2...5...8


Play this puzzle online

Download Sukaku Explainer

[SpAce]

Code: Select all

.---------.------------------------.---------.
| 4  8  1 |  9        7     2      | 3  6  5 |
| 7  9  3 |  56       68    58     | 2  4  1 |
| 6  2  5 | b4(+3)-1  13   a34[+1] | 7  8  9 |
:---------+------------------------+---------:
| 8  1  2 |  36       36    9      | 4  5  7 |
| 3  5  6 |  8        4     7      | 9  1  2 |
| 9  4  7 | a25[+1]  c2(1)  5-1    | 8  3  6 |
:---------+------------------------+---------:
| 5  3  8 |  7        9     6      | 1  2  4 |
| 1  6  9 | b24      c28    48     | 5  7  3 |
| 2  7  4 |  13       5     13     | 6  9  8 |
'---------'------------------------'---------'

(1)r3c6|r6c4 =BUG= (34-2)r38c4 = (21)r86c5 => -1 r3c4,r6c6; stte

[SteveG48]

Code: Select all

 *---------------------------------------------------*
 | 4    8    1    | 9     7    2    | 3    6    5    |
 | 7    9    3    | 56    68  b58   | 2    4    1    |
 | 6    2    5    | 134   13   134  | 7    8    9    |
 *----------------+-----------------+----------------|
 | 8    1    2    | 36    36   9    | 4    5    7    |
 | 3    5    6    | 8     4    7    | 9    1    2    |
 | 9    4    7    | 15-2 a12  b15   | 8    3    6    |
 *----------------+-----------------+----------------|
 | 5    3    8    | 7     9    6    | 1    2    4    |
 | 1    6    9    |c24    8-2 b48   | 5    7    3    |
 | 2    7    4    | 13    5    13   | 6    9    8    |
 *---------------------------------------------------*


(2=1)r6c5 - (1=584)r268c6 - (4=2)r8c4 => -2 r6c4,r8c5 ; stte

[rjamil]

Hidden Text: Show

Don't know how to prove it, but theoretically (not interested) there might be a BUG+2 => 3 @ r3c6 => 1 @ r6c4

Code: Select all

 +---------+-------------------+---------+
 | 4  8  1 | 9     7     2     | 3  6  5 |
 | 7  9  3 | 56    68    58    | 2  4  1 |
 | 6  2  5 | 34-1  (13)  1(3)4 | 7  8  9 |
 +---------+-------------------+---------+
 | 8  1  2 |*36   *36    9     | 4  5  7 |
 | 3  5  6 | 8     4     7     | 9  1  2 |
 | 9  4  7 | 125   12    15    | 8  3  6 |
 +---------+-------------------+---------+
 | 5  3  8 | 7     9     6     | 1  2  4 |
 | 1  6  9 | 24    28    48    | 5  7  3 |
 | 2  7  4 | (13)  5     1(3)  | 6  9  8 |
 +---------+-------------------+---------+

Step 1) W-Wing: 13 @ r3c5 r9c4 SL Column 6 between 3 @ r3c6 and 3 @ r9c6 => -1 @ r3c4; and
(or *SL Row 4 between 3 @ r3c4 and 3 @ r3c5)

Code: Select all

 +---------+-----------------+---------+
 | 4  8  1 | 9     7     2   | 3  6  5 |
 | 7  9  3 | 56    68    58  | 2  4  1 |
 | 6  2  5 | (34)  (13)  134 | 7  8  9 |
 +---------+-----------------+---------+
 | 8  1  2 | 36    36    9   | 4  5  7 |
 | 3  5  6 | 8     4     7   | 9  1  2 |
 | 9  4  7 | 15-2  (12)  15  | 8  3  6 |
 +---------+-----------------+---------+
 | 5  3  8 | 7     9     6   | 1  2  4 |
 | 1  6  9 | (24)  8-2   48  | 5  7  3 |
 | 2  7  4 | 13    5     13  | 6  9  8 |
 +---------+-----------------+---------+

Step 2) Almost Locked Set move: 1234 @ r36c5 r38c4 => -2 @ r8c5 r6c4; stte

R. Jamil

[SpAce]

Hi rjamil,

Don't know how to prove it, but theoretically (not interested) there might be a BUG+2 => 3 @ r3c6 => 1 @ r6c4

Not sure what you mean exactly, but if it's a BUG (and it is; see my solution) it must be a BUG+3 as there are three trivalue cells. The three guardians are 3r3c4, 1r3c6, and 1r6c4. At least one of them must be true in the solution to prevent the BUG.

How do we use that information? By finding eliminations they all can agree with. In fact, there's one candidate they all see directly: 1r3c4. That can be eliminated without any chaining, but it doesn't help much.

Two of the guardians (the 1s) also see 1r6c6 which is an stte-elimination. To get that, we need a chain starting from the remaining guardian 3r3c4 that would also eliminate it. That way we've proved that they all could kill it, so it can be eliminated.

Here's an alternative BUG+3 solution using a different stte-elimination (1r6c5):

Code: Select all

.---------.--------------------------.---------.
| 4  8  1 |  9          7     2      | 3  6  5 |
| 7  9  3 |  56         68    58     | 2  4  1 |
| 6  2  5 | a4[+3]-1  a[1]3  b34+1   | 7  8  9 |
:---------+--------------------------+---------:
| 8  1  2 |  36         36    9      | 4  5  7 |
| 3  5  6 |  8          4     7      | 9  1  2 |
| 9  4  7 | a25[+1]   c(2)-1  15     | 8  3  6 |
:---------+--------------------------+---------:
| 5  3  8 |  7          9     6      | 1  2  4 |
| 1  6  9 |  24        c28   b48     | 5  7  3 |
| 2  7  4 |  13         5     13     | 6  9  8 |
'---------'--------------------------'---------'

(1)r6c4|(1,3)r3c54 =BUG= (14-8)r3c6 = (82)r86c5 => -1 r3c4,r6c5; stte

The logic is probably easier to see with a kraken:

Code: Select all

(1)r6c4
||
(3)r3c4 - (3=1)r3c5
||
(1-4)r3c6 = (4-8)r8c6 = (8-2)r8c5 = (2)r6c5

=> -1 r3c4,r6c5; stte

In other words, it starts with our three guardians (a known strong inference set, SIS) and generates a derived SIS from that with short chains. It proves that at least one of 1r6c4, 1r3c5, or 2r6c5 must be true. They all see 1r6c5 so it can be killed.

That's how you use any BUG+N.

[pjb]

Code: Select all

 4       8       1      | 9      7      2      | 3      6      5     
 7       9       3      | 56     68     58     | 2      4      1     
 6       2       5      | 134    13    b134    | 7      8      9     
------------------------+----------------------+---------------------
 8       1       2      | 36     36     9      | 4      5      7     
 3       5       6      | 8      4      7      | 9      1      2     
 9       4       7      | 125   a12     5-1    | 8      3      6     
------------------------+----------------------+---------------------
 5       3       8      | 7      9      6      | 1      2      4     
 1       6       9      | 24    a28    b48     | 5      7      3     
 2       7       4      | 13     5     b13     | 6      9      8     


(1=8)r68c5 - (8=134)r389c6 => -1 r6c6; stte

Phil

[ghfick]

For me, the easiest step is an XY Chain :

(8=5)r2c6 - (5=1)r6c6 - (1=2)r6c5 - (2=8)r8c5 => -8 r2c5 -8 r8c6

[rjamil]

Don't know how to prove it, but theoretically (not interested) there might be a BUG+2 => 3 @ r3c6 => 1 @ r6c4

Not sure what you mean exactly, but if it's a BUG (and it is; see my solution) it must be a BUG+3 as there are three trivalue cells. The three guardians are 3r3c4, 1r3c6, and 1r6c4. At least one of them must be true in the solution to prevent the BUG.

Many thanks for correcting that it was BUG+3 i/o BUG+2. Actually, I consider same BUG digit tri-value cells only.

Added as on 20200524:
Actually, I was misunderstanding BUG-n: whether 'n' represent number of cells that contain more than 2 values; or number of unique digits if removed from more than 2 value cells will create a BUG. In OP puzzle, of course, the BUG cells are three but the BUG digits are only two. (Observation taken from this post.)

R. Jamil

[SpAce]

Actually, I was misunderstanding BUG-n: whether 'n' represent number of cells that contain more than 2 values; or number of unique digits if removed from more than 2 value cells will create a BUG. In OP puzzle, of course, the BUG cells are three but the BUG digits are only two. (Observation taken from this post.)

It's actually neither of those. The modern count is based on the number guardian candidates -- not cells or digits. You're correct that in the past some have counted the N as the number of cells with more than two candidates (which in this case would also be 3), but that's no longer the case. It makes much more sense to use the total number of guardian candidates as the N because the elimination has to be proved for each of them. I can't think of any reason why the number of guardian cells or digits would be relevant.

[rjamil]

Hi SpAce,

Thanks for your responses. However, a quick google [sudoku bug+n "guardian candidates"] search diverted me towards dead end.

Could you please provide explanation for beginners/dummies about BUG+n move. (Actually, I thought that, this move is always give a solution to either unique or multi-solution puzzles; or solve regardless of puzzle uniqueness constraint.)

(Basically, I have achieved stable versions of my RJSudoku.c and RJSukaku.c solver programs, whose latest source codes are available in my GitHub site. Hope that, if there is c language compiler available in any platform then, they must be compiled to run accordingly. And now am move back to analyzing further techniques.)

R. Jamil

[SpAce]

Could you please provide explanation for beginners/dummies about BUG+n move.

Does this help? Note that the only trivial BUGs are when all of the guardians see the desired elimination(s) directly. Only BUG+1 is always trivial because the sole guardian must be true and can be placed. When N > 1 it's more likely that you need chains with at least some of the guardians. Here's a BUG+3 and a BUG+5 that need no chains, but they're pretty rare.

Remember that the only thing you know is that at least one of the guardians must be true, but you can't know which one(s). Some people have had the misconception that BUG+N logic is about figuring out which of the N candidates is/are true and then placing them (like in BUG+1). Not at all. It's about using these two facts: 1) at least one of them must be true, and 2) true candidates can't lie.

In other words, if you find an elimination that all of the guardians can agree with, it can be taken safely. The reason is that following the logic from a true candidate could never lead to an elimination of another true candidate, because they can't imply falsehoods. False candidates, on the other hand, can be coerced to imply anything, so they can always be made to agree with the true candidates (but not vice versa).

[rjamil]

Hi SpAce,

Does this help?

Not at all!!!

Actually, what I understand all about BUG+n now is that, if puzzle pencilmark state reached, where all unsolved cells having only bi-value remain, except 'n' cells, then check each digit from 'n' cells, if digit present in more than two cells within a same unit (i.e., either row or column or box) then that digit is marked as BUG digit; and that cell is marked as BUG cell. (Now, a question arises that, what to call the remaining digits in BUG cells?)

If, by placing a BUG-digit(s) in to BUG-cell(s) considered as T&E, then what would be considered to remove non-BUG-digit from BUG-cell(s)?

R. Jamil

[rjamil]

Hi SpAce,

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  67+2 | 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   9-6  | 2  79+6  4 | 16  17  5  |
| 4  26  5    | 8  67    1 | 3   27  9  |
| 7  1   29+6 | 3  9-6   5 | 68  28  4  |
+-------------+------------+------------+

Look into above mentioned puzzle state, taken from here, showing only three cells having more than two values; and rest unsolved cells having bi-values. Whereas 2r4c3, 6r7c5 and 6r9c3 are the three BUG-cells and BUG-values respectively.

If more than one BUG-cells have same BUG-value then, is it possible to eliminate BUG-value from cells that see/buddy/peer all same-value-BUG-cells safely? (And let ignore those BUG-value that are either one and only BUG-cell; or having no common buddy/peers same-value-BUG-cells.)

Similarly, I see solution containing all BUG-values in BUG-cells respectively. So, by placing BUG-value in BUG-cell, why it is considered as T&E?

R. Jamil

[SpAce]

Hi rjamil,

I'd written most of this before I noticed your second post, so this only addresses the first one. I'll look at the other one shortly.

Does this help?

Not at all!!!

Well, that's discouraging, but it's good that you give honest feedback. It's much better to tell frankly if you don't understand something.

Actually, what I understand all about BUG+n now is that, if puzzle pencilmark state reached, where all unsolved cells having only bi-value remain, except 'n' cells, then check each digit from 'n' cells, if digit present in more than two cells within a same unit (i.e., either row or column or box) then that digit is marked as BUG digit guardian; and that cell is marked as BUG guardian cell.

Not so fast. That's almost correct, but not quite. If you apply that algorithm to the current puzzle, for example, and fail to do any other checks, you might end up with this and think you've found a BUG and its guardians:

Code: Select all

.---------.----------------.---------.
| 4  8  1 | 9     7   2    | 3  6  5 |
| 7  9  3 | 56    68  58   | 2  4  1 |
| 6  2  5 | 34+1  13  14+3 | 7  8  9 |
:---------+----------------+---------:
| 8  1  2 | 36    36  9    | 4  5  7 |
| 3  5  6 | 8     4   7    | 9  1  2 |
| 9  4  7 | 25+1  12  15   | 8  3  6 |
:---------+----------------+---------:
| 5  3  8 | 7     9   6    | 1  2  4 |
| 1  6  9 | 24    28  48   | 5  7  3 |
| 2  7  4 | 13    5   13   | 6  9  8 |
'---------'----------------'---------'

Does that look like a BUG+3 to you? At first glance it might because removing those three +candidates would leave only bivalue cells behind, and most of the bilocation checks work too, as you'd have only two of 1s and 3s each in box 2 and row 3 if the +candidates were removed. However, you have either one or three of them in columns 4 and 6. Clearly that can't work, since a BUG needs either zero or two of every digit in every house. Removing those +candidates would give you two hidden singles (1r9c4 and 3r9c6) which can't happen with a real BUG. Thus, this is not a BUG with that guardian configuration.

The easiest way to avoid such hazards is to mark the most unambiguous guardians first, which usually resolves the rest too. In this case it's easiest to start with the trivalue cell r6c4. Since both 2 and 5 exist precisely twice in all of their units, they can't be guardians. That leaves the 1 as the only possibility. Since there are three 1s in all of its houses (box, row, column) it can be marked as a guardian. It also means that 1r3c4 (which was originally ambiguous) can't be a guardian because removing both that and 1r6c4 would leave only one 1 in column 4. That leaves 3r3c4 as the only possibility since the 4 exists exactly twice in all of its houses. That also locks the 1r3c6 as the last remaining guardian (we could have known that directly too, because there are only two 3s in column 6, so it can be neither 3 nor 4).

If you apply that process systematically, you'll end up with one of three possibilities: 1) you found a single BUG and all of its guardians, 2) you found a multi-BUG (i.e. multiple possible BUGs with different sets of guardians), or 3) you found that a BUG is not possible in the current puzzle state. There are some advanced (and mostly theoretical) things you can do with options 2 and 3, but mostly we dismiss them, and only continue BUG solving with option 1.

(Now, a question arises that, what to call the remaining digits in BUG guardian cells?)

I've called them "BUG candidates" since they're actually part of the BUG (deadly pattern) itself. The extras are guardians or guardian candidates since their existence ensures the puzzle remains valid by preventing the BUG from forming. I strongly advice against calling the guardians "BUG digits" or "BUG values", because they specifically are not part of the BUG. Similarly I recommend calling their cells guardian cells instead of "BUG cells" (because in a BUG situation every unsolved cell is logically a "BUG cell"). "Guardian" is a standard term in the context of any deadly pattern, so please start using that to avoid misunderstandings. (Ignore any other terms you've possibly seen in ancient posts. They're obsolete.)

Note also that a single guardian cell can have more than one guardian candidate. That's why you could have, for example, three guardian cells but five actual guardians. That would be BUG+5 instead of BUG+3. Like I said, 'N' is the count of the actual guardian candidates instead of the guardian cells. (Again, if you find conflicting information in ancient posts, ignore that. This is the current standard, and the only one that makes sense.)

If, by placing a guardian(s) in to guardian-cell(s) considered as T&E, then what would be considered to remove a non-guardian from guardian cell(s)?

I'm not exactly sure what you're asking or if I translated that correctly into the standard terminology. In any case, if you're going to use T&E anyway, there's no reason to even find the BUG and its guardians. It's mostly just a waste of time in that case. Just use T&E directly on any candidate that seems like a good elimination and forget about BUGs.

(Btw, I presume you know the difference between T&E and guessing? In any case the difference is that T&E only accepts contradictions and their resulting eliminations. Guessing accepts also solutions found directly by trying a candidate without proving any eliminations. Of those T&E is considered a valid, if not very elegant, solving method and proof of a step. Guessing is not, even if it may very well be the fastest way to solve a puzzle.)

Anyway, if you do find the BUG and still want to use T&E instead of real BUG solving, there's a smart way and an extremely dumb way to do it. The smart way is to try to eliminate non-guardians via contradictions, because that can solve the puzzle with just a single elimination or a few at most. However, if you use T&E on guardian candidates, you'll run into a dead end. The only way that would make sense is if you accept guessing, but we don't even consider that possibility.

What happens if you T&E guardian candidates? If it's a true candidate, it will eventually lead to a solution. Yet, since we don't accept guesses that doesn't help at all, so we just discard the result. If it's a false candidate, it will run into a contradiction and we can eliminate it. However, eliminating a guardian will never solve the puzzle. All it does is reduce the size of the N by one, but a BUG+(N-1) still remains. So, even if you eliminate all false guardians, you still have to use normal BUG-solving or some other method to finish the puzzle. The luckiest case is if there's only one true guardian, which means you'll end up with BUG+1 after eliminating all the false ones. However, there's no guarantee of that, because there may be many true guardians (possibly all of them). So why not just place the remaining guardians if you're pretty sure they must be true candidates? You could, but that's still (a very informed way of) guessing, and as such it's not an acceptable solving step (unless your only goal is to find the solution no matter what). In any case it's an extremely dumb and inefficient way to use a BUG, so don't.

Btw, BUGs and T&E was covered extensively in this thread. The original poster used exactly what I just described as the "extremely dumb" T&E strategy, i.e. tried to eliminate all false guardians via contradictions. Pointing out the horrible inefficiency of that approach (and its clearly faulty implementation), and a few other errors of his ways, was probably why that person got so mad at me that he had to resort to slandering recently. Some people simply can't admit their mistakes, which is why they'll never learn. (Sure, I could have been more diplomatic, but my patience was running thin.)

So, once more. If you really wish to solve a BUG+N situation with T&E, do not test the guardian candidates. It's the dumbest thing you could do, unless you accept guessing (don't). The only other reason that makes some sense is if you want to reduce the number of guardians for an easier BUG solution. However, if you're using T&E anyway, you might as well do it all the way and target more effective candidates directly (i.e. non-guardians). If you invest in finding a BUG, learn to solve it like a BUG.

[SpAce]

grid: Show

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  67+2 | 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   9-6  | 2  79+6  4 | 16  17  5  |
| 4  26  5    | 8  67    1 | 3   27  9  |
| 7  1   29+6 | 3  9-6   5 | 68  28  4  |
+-------------+------------+------------+

Look into above mentioned puzzle state, taken from here, showing only three cells having more than two values; and rest unsolved cells having bi-values. Whereas 2r4c3, 6r7c5 and 6r9c3 are the three BUG-cells and BUG-values respectively.

This would be my BUG solution for that puzzle state:

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    6-2  a67(+2) | 9   8     3 | b1(2)  4   17 |
| 1    8     3      | 4   2     7 |  5     9   6  |
| 9    4     27     | 5   1     6 |  28    3   78 |
:-------------------+-------------+---------------:
| 8    3     69     | 2  b79+6  4 | b16    17  5  |
| 4  c(2)6   5      | 8   67    1 |  3     27  9  |
| 7    1    c29+6   | 3   69    5 |  68    28  4  |
'-------------------'-------------'---------------'

BUG+3 (as a kraken):

Code: Select all

(2)r4c3
||
(6)r7c5 - (6=1)r7c7 - (1=2)r4c7
||
(6)r9c3 - (6=2)r8c2

=> -2 r4c2; stte

In other words, one of the guardians (a:2r4c3) sees the elimination (2r4c2) directly so no chain needed for that. The other two (b:6r7c5 and c:6r9c3) don't see the elimination target directly, so they both need a short chain to imply a remote candidate (2r4c7 or 2r8c2 respectively) which does see the target. Since all guardians have been proved capable of eliminating the same target, that concludes the proof and we can eliminate it safely.

The same as an AIC:

(2)r4c3 = [(2=16)r47c7 - r7c5 =BUG= (6,2)b7p95] => -2 r4c2; stte

If more than one BUG-cells have same BUG-value then, is it possible to eliminate BUG-value from cells that see/buddy/peer all same-value-BUG-cells safely? (And let ignore those BUG-value that are either one and only BUG-cell; or having no common buddy/peers same-value-BUG-cells.)

If I understand what you're asking, the answer is yes if ALL of the guardians agree with that elimination, either by seeing it directly or remotely via chains, like above.

Similarly, I see solution containing all BUG-values in BUG-cells respectively. So, by placing BUG-value in BUG-cell, why it is considered as T&E?

It's not if you have BUG+1. Then you can safely place that single guardian because you know it must be true. It's the only such case, though. In any BUG+(N>1) you can't place any of the guardians because you can't know which ones are true and which ones are false. All you can do with them is to find eliminations with which they all agree, because you do know that at least one of them is true (and true candidates can't lie). There's no way around it. It's just normal kraken logic. Other than that, I discussed BUGs and T&E pretty extensively in the previous post.

PS. Please start using the standard terminology I outlined in the previous post. It makes communication easier and more accurate. Thanks.