With only three 3-candidate cells left, how would you attack this this as a BUG+3?

32..4.7.81572.84.384.3.7.2.682731..47956243814138..672538472...961583247274...835

Yogi

18 posts
• Page **1** of **2** • **1**, 2

How about:

Edit: On a second look, a much simpler chain is available for the third node (originally I just used the first I saw):

- Code: Select all
`+--------------+-------------------+----------------+`

| 3 2 69 | 19 4 56(+9) | 7 15 8 |

| 1 5 7 | 2 69 8 | 4 69 3 |

| 8 4 69 | 3 d15 7 |c15 2 69 |

+--------------+-------------------+----------------+

| 6 8 2 | 7 3 1 | 59 59 4 |

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

| 4 1 3 | 8 e59 f5(9) | 6 7 2 |

+--------------+-------------------+----------------+

| 5 3 8 | 4 7 2 |b19 a16+9 69 |

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

| 2 7 4 | 19 16(+9) 6-9 | 8 3 5 |

+--------------+-------------------+----------------+

- Code: Select all
`|(9)r1c6`

|(9)r9c5

|(9)r7c8-(9=1)r7c7-(1=5)r3c7-r3c5=(5-9)r6c5=(9)r6c6

=> -9 r9c6; stte

Edit: On a second look, a much simpler chain is available for the third node (originally I just used the first I saw):

- Code: Select all
`+--------------+-------------------+----------------+`

| 3 2 69 | 19 4 56(+9) | 7 15 8 |

| 1 5 7 | 2 c69 8 | 4 b69 3 |

| 8 4 69 | 3 15 7 | 15 2 69 |

+--------------+-------------------+----------------+

| 6 8 2 | 7 3 1 | 59 59 4 |

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

| 4 1 3 | 8 d59 e5(9) | 6 7 2 |

+--------------+-------------------+----------------+

| 5 3 8 | 4 7 2 | 19 a16+9 69 |

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

| 2 7 4 | 19 16(+9) 6-9 | 8 3 5 |

+--------------+-------------------+----------------+

- Code: Select all
`|(9)r1c6`

|(9)r9c5

|(9)r7c8 - r2c8 = r2c5 - r6c5 = (9)r6c6

=> -9 r9c6; stte

(Partly stolen from Steve's AIC solution below.)

Last edited by SpAce on Thu Jul 12, 2018 9:11 pm, edited 2 times in total.

- Code: Select all
`* | | | | *`

* |=()=| / _ \ |=()=| *

* | | |-=( )=-| | | *

* \ ¯ / *

- SpAce
**Posts:**1024**Joined:**22 May 2017

BUG+3's may be a fun challenge, but why bother when there is a little XY-wing ((9=1)r1c4 - (1=5)r3c5 - (5=9)r6c5 => -9 r2c5) that does the trick?

Phil

Phil

- pjb
- 2014 Supporter
**Posts:**2025**Joined:**11 September 2011**Location:**Sydney, Australia

pjb wrote:BUG+3's may be a fun challenge, but why bother when there is a little XY-wing ((9=1)r1c4 - (1=5)r3c5 - (5=9)r6c5 => -9 r2c5) that does the trick?

I would assume the poster is already proficient with XY-Wings and wants to learn a new trick. Besides, it's not clear-cut which is the easier technique. For example, I suck at spotting XY-Wings, especially when there are tons of bivalue cells around, but had no trouble finding the BUG+3 solution (in this case). The latter is more complex, of course, but at least you know where to start and what to look for. Finding XY-Wings is more random.

PS. Personally I'd spot this before the XY-Wing:

W-Wing: (6=9)r9c6 - r6c6 = r6c5 - (9=6)r2c5 => -6 r1c6, r9c5

- Code: Select all
`* | | | | *`

* |=()=| / _ \ |=()=| *

* | | |-=( )=-| | | *

* \ ¯ / *

- SpAce
**Posts:**1024**Joined:**22 May 2017

I’m with SpAce on this one, prefering BUG+3 over XY Wings. When you’re working with P&P it’s quite clear cut that the solution can be found in identifying the essential candidate that ‘Kills the BUG’ in one of the three 3-candidate cells, and it’s relatively easy to spot the important candidate for each of them. But what process do you use to identify the one that will solve the whole puzzle? I was not able to follow the reasoning in SpAce’s suggestion. Could you fill it out a bit more, please.

Yogi

Yogi

- Yogi
- 2017 Supporter
**Posts:**135**Joined:**05 December 2015**Location:**New Zealand

Yogi wrote:But what process do you use to identify the one that will solve the whole puzzle? I was not able to follow the reasoning in SpAce’s suggestion. Could you fill it out a bit more, please.

My process:

1. Identify the potential BUG+ cells (i.e. the ones with more than two candidates): r1c6, r7c8, r9c5 in this case.

2. Identify the potential BUG+ candidate(s) in each of those cells: 9r1c6, 9r7c8, 9r9c5 (other candidates are strongly linked in every direction).

3. Double-check that it would be a real BUG if all those candidates were eliminated (everything would be bivalue & bilocation; no weak links left in the puzzle).

4. Since this is a real BUG+ situation, at least one of those plus-candidates must be true in a single-solution puzzle; i.e. they form a strong inference set, SIS.

5. Find a candidate that gets eliminated regardless of which one of those plus-candidates is true (Kraken logic). Eliminating any strongly linked candidate is pretty much guaranteed to solve a (practical) BUG+ situation, so it really doesn't matter which one you find (because everything is strongly-linked except for the plus-candidates themselves). In this case, 9r9c6 seemed the obvious choice because it got attacked by two BUG+ candidates directly (9r1c6 and 9r9c5) and only required a chain for the third (9r7c8).

Did that help?

PS. My solution was presented as a three-way Kraken (straight-forward and easy to generalize for any BUG+n), but this particular case is also easy to see as an AIC as Steve demonstrated. Do you need help with that variant?

- Code: Select all
`* | | | | *`

* |=()=| / _ \ |=()=| *

* | | |-=( )=-| | | *

* \ ¯ / *

- SpAce
**Posts:**1024**Joined:**22 May 2017

Below is an example of a BUG+5 solved by a similar (but obviously five-way) Kraken approach. Like I said, that method scales to any BUG+n, but naturally it gets more difficult to apply as n gets bigger.

http://forum.enjoysudoku.com/historical-daily-41-t34834.html#p267283

http://forum.enjoysudoku.com/historical-daily-41-t34834.html#p267283

- Code: Select all
`* | | | | *`

* |=()=| / _ \ |=()=| *

* | | |-=( )=-| | | *

* \ ¯ / *

- SpAce
**Posts:**1024**Joined:**22 May 2017

Hey that's really good. Thanx

Yogi

Yogi

- Yogi
- 2017 Supporter
**Posts:**135**Joined:**05 December 2015**Location:**New Zealand

Yogi wrote:Hey that's really good. Thanx

Hi Yogi! I'm glad if I could help. Btw, I edited my first post to use a simpler chain. Should be easier to follow now.

Here's another exercise for you:

- Code: Select all
`851294006076083020023607008368425000592001684714869253607008192209006805185902067`

+--------------+--------------+--------------+

| 8 5 1 | 2 9 4 | 37 37 6 |

| 49 7 6 | 15 8 3 | 459 2 19 |

| 49 2 3 | 6 15 7 | 459 14 8 |

+--------------+--------------+--------------+

| 3 6 8 | 4 2 5 | 79 17 19 |

| 5 9 2 | 37 37 1 | 6 8 4 |

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

+--------------+--------------+--------------+

| 6 34 7 | 35 345 8 | 1 9 2 |

| 2 34 9 | 17 17 6 | 8 34 5 |

| 1 8 5 | 9 34 2 | 34 6 7 |

+--------------+--------------+--------------+

Original puzzle: 051000000006083020000007008300400000002000600710809003000000100209000000080900007

Can you solve it using the BUG+3 or would you like one more walk-through?

PS. I actually used the BUG+3 to solve this because it was the only thing I could easily see. Like your example, this also contains an XY-Wing (or two), but I could not find it in a reasonable time even though I was all but certain there was (at least) one! So there, it's now proven that BUG+3 really is the easier technique for me despite the added complexity. Besides, the XY-Wing is not a one-stepper here (it just turns it into a trivial BUG+1) while the BUG+3 is. (I actually solved this without pencil marks, but I don't think it made a difference -- I couldn't see the XY-Wing even after adding pencil marks, until I plugged it into a solver and let it show me. I'm that blind to them, which is a known leak in my game )

- Code: Select all
`* | | | | *`

* |=()=| / _ \ |=()=| *

* | | |-=( )=-| | | *

* \ ¯ / *

- SpAce
**Posts:**1024**Joined:**22 May 2017

851294..6.76.83.2..236.7..8368425...592..16847148692536.7..81922.9..68.51859.2.67

Just picking this one up again. The BUG-killing candidates are 9r2c7, 4r3c7 and/or 3r7c5. But how do you know which is the right one to start with?

It turns out that starting with 9 at r2c7 does not solve the puzzle, but starting with either of the others does. That seems a bit hit–or–miss.

Maybe there is something in your point 5 above that I don’t get.

Just picking this one up again. The BUG-killing candidates are 9r2c7, 4r3c7 and/or 3r7c5. But how do you know which is the right one to start with?

It turns out that starting with 9 at r2c7 does not solve the puzzle, but starting with either of the others does. That seems a bit hit–or–miss.

Maybe there is something in your point 5 above that I don’t get.

- Yogi
- 2017 Supporter
**Posts:**135**Joined:**05 December 2015**Location:**New Zealand

Yogi wrote:Just picking this one up again. The BUG-killing candidates are 9r2c7, 4r3c7 and/or 3r7c5.

Yes, they're the correct extra-candidates.

But how do you know which is the right one to start with?

It's easy -- you have to start with ALL of them. You still seem to have a fundamental misconception about what we're trying to do and what not when we have a BUG+n situation. Only BUG+1 gives us a direct placement because we only have one extra candidate and that must be the sole survivor. Don't confuse that with what we're doing here. When there's more than one extra, we only know that at least one of them must be true. We don't know which one(s), and we're NOT even trying to find out! Instead we use that group of extra candidates as a derived strong inference set to build interconnected chains that together eliminate something that solves the puzzle. The only thing we know for sure -- and which is enough -- is that all of those extra candidates can't be false. It means that if the chains emanating from each of them all prove the same thing (usually an elimination) then that thing must be so and we can safely act on it.

It turns out that starting with 9 at r2c7 does not solve the puzzle, but starting with either of the others does. That seems a bit hit–or–miss.

That's because the 9r2c7 will end up being false and the other two true, but that's not important at all. We don't care about that. You should not be trying to find out which of those candidates are true and false. That would be called guessing (when looking for true candidates) or trial&error (when looking for false candidates), and most of us prefer not to solve puzzles like that. Of course in more complicated BUG+n situations you could first eliminate some extra candidates to simplify the situation, but we don't need to do that here.

Maybe there is something in your point 5 above that I don’t get.

It seems so. I'll try to explain again with my solution:

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

| 8 5 1 | 2 9 4 | 37 37 6 |

| 49 7 6 |b15 8 3 |a45#9 2 19 |

| 49 2 3 | 6 15 7 | 59(#4) 14 8 |

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

| 3 6 8 | 4 2 5 | 79 17 19 |

| 5 9 2 | 37 37 1 | 6 8 4 |

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

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

| 6 34 7 |c35 A45#3 8 | 1 9 2 |

| 2 34 9 | 17 17 6 | 8 34 5 |

| 1 8 5 | 9 dB3(4) 2 | 3-4 6 7 |

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

BUG+3

(4)r3c7 - (4)r9c7

||

(9-5)r2c7 = r2c4 - (5=3)r7c4 - (3=4)r9c5 - (4)r9c7

||

(3)r7c5 - (3=4)r9c5 - (4)r9c7

=> -4 r9c7; stte

How to interpret that? First, we know that at least one of those extra candidates must be true to prevent the BUG. Thus they form a derived strong inference set: (4)r3c7 == (9)r2c7 == (3)r7c5 (expressed vertically above). We don't know which one(s) of them is/are true, but we do know that they can't all be false. That's enough to prove something, because if ALL of them lead to a certain same conclusion then that conclusion must be true. In this case that conclusion is the elimination of 4r9c7. Our first extra candidate 4r3c7 would eliminate it directly, and the other two using short chains that both end with 4r9c5. The chains prove that either 4r3c7 or 4r9c5 (or both) must be true, and thus 4r9c7 can't be true. Thus it can be eliminated and the puzzle is solved. It's just like an AIC except with three strongly linked end nodes instead of two, and it proves that at least one of them must be true (and anything weakly linked to them all can't be). The essence of our logic is here (without the proving chains):

BUG+3 -> [ 4r3c7 OR 9r2c7 OR 3r7c5 ] -> [ 4r3c7 OR 4r9c5 ] => -4 r9c7; stte

Note that our proof tells nothing about the truth values of the extra BUG-candidates themselves. They'll get solved with the rest of the puzzle once that stte elimination we found using them is performed. In other words, they just form a hub to use for building chains which all lead to the same conclusion.

Did that clarify anything (or perhaps confuse even more)?

PS. I wrote the above kraken with the elimination at the end of each chain to make it clear that each branch has the same conclusion. Usually I would leave it out and write it like this (just like AICs):

(4)r3c7

||

(9-5)r2c7 = r2c4 - (5=3)r7c4 - (3=4)r9c5

||

(3)r7c5 - (3=4)r9c5

=> -4 r9c7; stte

- Code: Select all
`* | | | | *`

* |=()=| / _ \ |=()=| *

* | | |-=( )=-| | | *

* \ ¯ / *

- SpAce
**Posts:**1024**Joined:**22 May 2017

Here's another way to solve it using two steps.

First, if we look at the most obvious chains emanating from those three extra candidates (when assumed true), we'll quickly notice that they would produce different results:

(4)r3c7 - (4)r9c7

||

(9)r7c7 - (9=7)r4c7 - (7=3)r1c7 - (3)r9c7 = (4)r9c7

||

(3)r7c5 - (3=4)r9c5 - (4)r9c7

So, two of those (4 and 3) would eliminate 4r9c7 and one (9) would instead place the same candidate. Because they don't agree, we can't conclude anything about the target candidate (4r9c7) using those chains. However, since both results can't be true, we now know that at least one of our extra candidates must be false (in addition to already knowing that at least one of them must be true).

How do we know which one(s) is/are false? Well, false candidates have the interesting property that they can produce contradicting results with different chaining paths, which is a direct way of identifying them. True candidates always produce the same conclusions no matter how you chain them, but false ones can (and eventually will) produce conflicting results depending on the path taken. To find our culprit, we might want to test the odd man 9r2c7 first and see if we can find a different chain that would make it agree with the majority -- and yes, we can:

(9-5)r2c7 = r2c4 - (5=3)r7c4 - (3=4)r9c5 - (4)r9c7

In other words, placing 9r2c7 would turn 4r9c7 both on and off, which is an obvious conflict. We now have two options to take advantage of that: either use that second chain in a kraken to eliminate 4r9c7 directly like before (because then all three chains agree with that result), or we can eliminate 9r2c7 and proceed with a simpler BUG+2. However, if we choose that second option, we don't want to use our Nishio deduction to report that elimination, so we'll figure out a corresponding AIC to do that. For example:

Step 1: (5)r2c7 = r2c4 - (5=3)r7c4 - (3=4)r9c5 - (4=3)r9c7 - (3=7)r1c7 - (7=9)r4c7 => -9 r2c7

After that we have a BUG+2. That's much simpler to solve, because we now have just two strongly linked extras: (4)r3c7 == (3)r7c5. We already know that they both have a simple path to eliminate 4r9c7, and it could be expressed with this two-way kraken:

(4)r3c7 - (4)r9c7

||

(3)r7c5 - (3=4)r9c5 - (4)r9c7

=> -4 r9c7; stte

However, since that kraken only has two chains, it can (and should) be written as a simple AIC (like any BUG+2 solutions):

Step 2: (4)r3c7 == (3)r7c5 - (3=4)r8c5 => -4 r9c7; stte

Could that two-step solution be an easier approach to understand for you? In this case it doesn't make much practical sense, though, because eliminating that 9r2c7 requires a much longer AIC than solving the puzzle directly with an XY-Wing or something. (Of course the same could be said about using the BUG+3 here in general, but for some reason I still found it easier than spotting the XY-Wing.)

Anyway, it's just an example how you can simplify a BUG+n situation by reducing those extra candidates first. In your own original example 2/3 extras were actually false, so you could have reduced it to BUG+1 which is obviously trivial to solve. (That approach would have made even less practical sense than here, though.)

First, if we look at the most obvious chains emanating from those three extra candidates (when assumed true), we'll quickly notice that they would produce different results:

(4)r3c7 - (4)r9c7

||

(9)r7c7 - (9=7)r4c7 - (7=3)r1c7 - (3)r9c7 = (4)r9c7

||

(3)r7c5 - (3=4)r9c5 - (4)r9c7

So, two of those (4 and 3) would eliminate 4r9c7 and one (9) would instead place the same candidate. Because they don't agree, we can't conclude anything about the target candidate (4r9c7) using those chains. However, since both results can't be true, we now know that at least one of our extra candidates must be false (in addition to already knowing that at least one of them must be true).

How do we know which one(s) is/are false? Well, false candidates have the interesting property that they can produce contradicting results with different chaining paths, which is a direct way of identifying them. True candidates always produce the same conclusions no matter how you chain them, but false ones can (and eventually will) produce conflicting results depending on the path taken. To find our culprit, we might want to test the odd man 9r2c7 first and see if we can find a different chain that would make it agree with the majority -- and yes, we can:

(9-5)r2c7 = r2c4 - (5=3)r7c4 - (3=4)r9c5 - (4)r9c7

In other words, placing 9r2c7 would turn 4r9c7 both on and off, which is an obvious conflict. We now have two options to take advantage of that: either use that second chain in a kraken to eliminate 4r9c7 directly like before (because then all three chains agree with that result), or we can eliminate 9r2c7 and proceed with a simpler BUG+2. However, if we choose that second option, we don't want to use our Nishio deduction to report that elimination, so we'll figure out a corresponding AIC to do that. For example:

Step 1: (5)r2c7 = r2c4 - (5=3)r7c4 - (3=4)r9c5 - (4=3)r9c7 - (3=7)r1c7 - (7=9)r4c7 => -9 r2c7

After that we have a BUG+2. That's much simpler to solve, because we now have just two strongly linked extras: (4)r3c7 == (3)r7c5. We already know that they both have a simple path to eliminate 4r9c7, and it could be expressed with this two-way kraken:

(4)r3c7 - (4)r9c7

||

(3)r7c5 - (3=4)r9c5 - (4)r9c7

=> -4 r9c7; stte

However, since that kraken only has two chains, it can (and should) be written as a simple AIC (like any BUG+2 solutions):

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

| 8 5 1 | 2 9 4 | 37 37 6 |

| 49 7 6 | 15 8 3 | 45 2 19 |

| 49 2 3 | 6 15 7 |a59(#4) 14 8 |

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

| 3 6 8 | 4 2 5 | 79 17 19 |

| 5 9 2 | 37 37 1 | 6 8 4 |

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

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

| 6 34 7 | 35 b45#3 8 | 1 9 2 |

| 2 34 9 | 17 17 6 | 8 34 5 |

| 1 8 5 | 9 c3(4) 2 | 3-4 6 7 |

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

Step 2: (4)r3c7 == (3)r7c5 - (3=4)r8c5 => -4 r9c7; stte

Could that two-step solution be an easier approach to understand for you? In this case it doesn't make much practical sense, though, because eliminating that 9r2c7 requires a much longer AIC than solving the puzzle directly with an XY-Wing or something. (Of course the same could be said about using the BUG+3 here in general, but for some reason I still found it easier than spotting the XY-Wing.)

Anyway, it's just an example how you can simplify a BUG+n situation by reducing those extra candidates first. In your own original example 2/3 extras were actually false, so you could have reduced it to BUG+1 which is obviously trivial to solve. (That approach would have made even less practical sense than here, though.)

- Code: Select all
`* | | | | *`

* |=()=| / _ \ |=()=| *

* | | |-=( )=-| | | *

* \ ¯ / *

- SpAce
**Posts:**1024**Joined:**22 May 2017

Nearly there, I think. I recently used my interpretation of this approach in a BUG+2:

5..16832..8297.516...25.8.98...351.2..562198.12..8965.9..542768648317295257896431

The BUG cells with their essential candidates are 4r3c1 and 4r6c9.

Knowing that at least one of these must be true, we can find something else that MUST be true, a verity, if both those assumptions can lead to it.

Here, we find that 4r3c1 => 4r6c3 => 4r4c4 AND 4r6c9 => 4r4c4, therefore r4c4 = 4 .

Trivial perhaps, but it is illustrative of the principle that is being applied.

So returning the to the BUG+3 problem above, MY interpretation of the method outlined by SpAce is that, knowing that at least one of the extra candidates must be true, the puzzle could be solved (or at least advanced) by identifying a 3-case verity that is forced by assuming, in turn, each of the extra candidates in the three BUG cells.

Of course this may be much more complicated and difficult than the simpler 2-case scenario in the BUG+2, and it is possibly more likely that an inconsistency would be discovered which would reduce the problem to a BUG+2.

5..16832..8297.516...25.8.98...351.2..562198.12..8965.9..542768648317295257896431

The BUG cells with their essential candidates are 4r3c1 and 4r6c9.

Knowing that at least one of these must be true, we can find something else that MUST be true, a verity, if both those assumptions can lead to it.

Here, we find that 4r3c1 => 4r6c3 => 4r4c4 AND 4r6c9 => 4r4c4, therefore r4c4 = 4 .

Trivial perhaps, but it is illustrative of the principle that is being applied.

So returning the to the BUG+3 problem above, MY interpretation of the method outlined by SpAce is that, knowing that at least one of the extra candidates must be true, the puzzle could be solved (or at least advanced) by identifying a 3-case verity that is forced by assuming, in turn, each of the extra candidates in the three BUG cells.

Of course this may be much more complicated and difficult than the simpler 2-case scenario in the BUG+2, and it is possibly more likely that an inconsistency would be discovered which would reduce the problem to a BUG+2.

- Yogi
- 2017 Supporter
**Posts:**135**Joined:**05 December 2015**Location:**New Zealand

Yogi wrote:Nearly there, I think.

Looks like it!

I recently used my interpretation of this approach in a BUG+2:

5..16832..8297.516...25.8.98...351.2..562198.12..8965.9..542768648317295257896431

The BUG cells with their essential candidates are 4r3c1 and 4r6c9.

Knowing that at least one of these must be true, we can find something else that MUST be true, a verity, if both those assumptions can lead to it.

Here, we find that 4r3c1 => 4r6c3 => 4r4c4 AND 4r6c9 => 4r4c4, therefore r4c4 = 4 .

Trivial perhaps, but it is illustrative of the principle that is being applied.

Your logic is absolutely correct. It's indeed a good idea to start with BUG+2 situations and expand from there. The logic is the same for all BUG+n situations, no matter how big n is. Here's another way to express your logic (just showing the corresponding elimination which leads to your placement and others):

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

| 5 79 49 | 1 6 8 | 3 2 47 |

| 34 8 2 | 9 7 34 | 5 1 6 |

|b37#4 16 16 | 2 5 34 | 8 47 9 |

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

| 8 69 69 | 47 3 5 | 1 47 2 |

|c47 37 5 | 6 2 1 | 9 8 34 |

| 1 2 d3(4) | 7-4 8 9 | 6 5 a37(#4) |

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

| 9 13 13 | 5 4 2 | 7 6 8 |

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

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

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

BUG+2:

(4)r3c1 - r5c1 = (4)r6c3

||

(4)r6c9

=> -4 r6c4 (=> +4 r4c4, +7r6c4 ...); stte

...or, since it's a two-way kraken, it's preferable to write it as an AIC:

(4)r6c9 =BUG= (4)r3c1 - r5c1 = (4)r6c3 => -4 r6c4; stte

So returning the to the BUG+3 problem above, MY interpretation of the method outlined by SpAce is that, knowing that at least one of the extra candidates must be true, the puzzle could be solved (or at least advanced) by identifying a 3-case verity that is forced by assuming, in turn, each of the extra candidates in the three BUG cells.

Of course this may be much more complicated and difficult than the simpler 2-case scenario in the BUG+2, and it is possibly more likely that an inconsistency would be discovered which would reduce the problem to a BUG+2.

I think you've understood everything correctly. If you want more case studies, here's a couple of recent BUG+n examples from the daily puzzles:

BUG+5 (SteveC). Very cool -- no chains needed at all!

BUG+3 (SpAce). No chains needed.

BUG+9 (Cenoman). Wow!

BUG+3 (SpAce). Nothing special.

BUG+7: (Cenoman), (SpAce). (Same BUG, different chains.)

- Code: Select all
`* | | | | *`

* |=()=| / _ \ |=()=| *

* | | |-=( )=-| | | *

* \ ¯ / *

- SpAce
**Posts:**1024**Joined:**22 May 2017

18 posts
• Page **1** of **2** • **1**, 2