Sudoku Players' Forum (clone)

I've been trying to understand the difference between BUG+1,2,3... and BUG-Lite, but after reading all of the information I can find on the subject, I'm still in the dark. They seem the same to me. Can someone explain the difference, or point me to a source that clearly explains the difference?

RSW wrote:I've been trying to understand the difference between BUG+1,2,3... and BUG-Lite, but after reading all of the information I can find on the subject, I'm still in the dark. They seem the same to me. Can someone explain the difference, or point me to a source that clearly explains the difference?

I'm not sure, but it seems to me that some folks use the term BUG-Lite to refer to any deadly pattern not a unique rectangle. BUG+ refers to patterns involving all unsolved cells.

As the name implies, all of the BUG (Bivalue Universal Grave) variants would include only bivalue cells in their deadly form (i.e. if all plus-candidates were removed, which would result in multiple solutions). That makes them different from MUGs (Multi-value Universal Graves) which can have more than two candidates/cell in their deadly form.

So that's what's common to both BUGs and BUG-Lites (including URs), but what's their difference?

As Steve said, full BUG-patterns use all of the unsolved cells. Here's a discussion about those, with links to examples (including a ridiculous BUG+23 solution by myself).

BUG-Lites, on the other hand, contain only a subset of the unsolved cells, so the pattern is isolated from the rest of the grid. Unique Rectangles (URs) are the simplest and the most common kind of BUG-Lite, using only four cells and two digits. Full BUGs are the opposite, using every unsolved cell. Any bivalue uniqueness pattern between those two extremes is called BUG-Lite. Simple as that. (When the pattern is fully contained in one chute, some might also call it Extended Unique Rectangle -- note that only the second example behind that link is a BUG-Lite, though, while the other two are MUGs).

Here's a couple of recent examples of BUG-Lites (although I just called them DPs which is a generic name for all deadly patterns):

http://forum.enjoysudoku.com/post274301.html#p274301
http://forum.enjoysudoku.com/post274219.html#p274219
http://forum.enjoysudoku.com/post274165.html#p274165
http://forum.enjoysudoku.com/post273999.html#p273999 (also has a BUG+2, as demonstrated by Cenoman)

Thanks very much SteveG48 and SpAce. That explains it clearly.
I've just finished adding BUG+N code to my solver, and wanted to know if I'd overlooked anything. I'll be looking at adding adding unique rectangles next. Then I'll see what's involved in BUG-Lite logic. It sounds sufficiently general that it may not be very easy to implement as a single technique, and may not be worth the effort.

Followed by
Mugs, mug light, r

Ur types 1-6
Ur chain extensions

Reverse bug
Reverse bug light

Hidden ur type 1-2
And finllly aurs

And then you'll have the unique stuff covered.

StrmCkr wrote:And finllly aurs

What do you mean by AUR? I've thought it's just an old alias for UR and shouldn't be used these days because it causes confusion. I don't see any meaningful definition for an almost-UR anyway, unless you also specify the type. For example, Almost-'UR Type 1' makes sense and can be used in chains, but the generic pattern is still a UR and not an almost-UR. What's confusing about URs is that they're not deadly patterns themselves (unlike BUGs etc) -- they just contain a deadly pattern (but the plus-candidates as well). Thus it's incorrect to call a UR Type 1 pattern "almost-UR" or "UR+1", for example.

If you want unique rectangles you could do 1-6 and hidden, but those types don't cover every possible pattern.
Its maybe better to start with new namings.

-Unique rectangles inner chains (Type 1,4,6 + hiddens)
-Unique rectangles + 1 common peer (Type 2,5)
-Unique rectangles + 1 almost locked set (Type 3)
-Unique rectangles chains/sets.. how far do you want to go?
-MUGS, but how to find them all?

creint wrote:If you want unique rectangles you could do 1-6 and hidden, but those types don't cover every possible pattern.
Its maybe better to start with new namings.

Or maybe to forget about them? Like with many other patterns such as wings etc, enumerating and memorizing every possibility is mostly a waste of time and it can even hinder deeper learning. It's much more important to understand the simple principles behind any patterns because then you can apply them directly, even in situations that aren't covered by any standard patterns.

With URs and any other DP+Ns (not just uniqueness types) all you need to understand is that at least one of the DP-breaking candidates must be true, i.e. in AIC-terms they're strongly-linked (usually strong-only, as they're rarely weakly-linked as well). Those DP-breaking candidates can be either internal or external to the pattern, or even a mixed set (named UR types only use internals). That's all you need to know to derive various eliminations, including those from the named patterns.

If you look at the Puzzles section on this forum, DP+Ns including URs are used a lot, but you'll almost never see any Type-designations with them. That's because the standard UR types would never solve the puzzle in one step (that would be considered too easy), and there's no real need to memorize them anyway. In the end, all DP+Ns are just generators for derived strong-links, nothing more (or less). Also, any impossible pattern can be used as a DP -- which I incidentally did with today's puzzle.

Almost unique rectangle is a deadly pattern that exsits as a result of conditions of a chain/pattern forming the expression of a deadly state. While examining the outcome of a construct. With out the constructs influence the ur state isn't visible.

http://forum.enjoysudoku.com/almost-unique-rectangles-description-and-use-in-nice-loops-t2751.html

There is also amost bugs and mugs.... (I've used almost mugs to solve some stuff in the past posted here some where)
but yeah... Too much stuff...

StrmCkr wrote:Almost unique rectangle is a deadly pattern that exsits as a result of conditions of a chain/pattern forming the expression of a deadly state. While examining the outcome of a construct. With out the constructs influence the ur state isn't visible.

http://forum.enjoysudoku.com/almost-unique-rectangles-description-and-use-in-nice-loops-t2751.html

That's what I thought you meant, but I don't agree with that definition. Like I said before, a UR is a UR no matter how many extra candidates it has. Thus I think Carcul's examples are simply URs and not AURs. The only time the almost-prefix makes sense is if you use it with an exact UR type. Otherwise it's meaningless.

http://forum.enjoysudoku.com/post67031.html#p67031

Found the almost mug.

StrmCkr wrote:http://forum.enjoysudoku.com/post67031.html#p67031

Found the almost mug.

A very nice solution, but I don't see anything "almost" there. I just see a MUG+3. I'd express it like this:

Code: Select all

.-----------------.-----------------.-------------------.
|  7     b128+  4 | b18+    5  189  | 6     3     b12+9 |
| a5(8)  b12+5  9 |  36     4  36   | 1-8   7     b12+  |
|  3     b1-8+  6 | b18+9   2  7    | 5    c4(8)  c49   |
:-----------------+-----------------+-------------------:
|  59     6     2 |  7      8  49   | 3     145    145  |
|  1      45    7 |  26     3  26   | 49    459    8    |
|  89     48    3 |  49     1  5    | 2     6      7    |
:-----------------+-----------------+-------------------:
|  6      7     8 |  1245   9  124  | 14    1245   3    |
|  24     9     1 |  23458  6  2348 | 7     2458   45   |
|  24     3     5 |  1248   7  1248 | 1489  12489  6    |
'-----------------'-----------------'-------------------'

MUG+3[128]r123c2,r13c4,r12c9 (UR[12]r12c29 overlapping UR[18]r13c24) using internals:

(8=5)r2c1 - (5=[MUG+3]=9)r123c2,r13c4,r12c9 - (9=48)r3c98 => -8 r2c7,r3c2; stte

PS. Of course any DP+N can be thought of as an almost-DP (because without the N candidates it would be a DP), but since a real DP can't exist in a valid puzzle or in a verity chain, using the "almost" word with them is a bit confusing. I'd reserve it for patterns that can exist and perform eliminations in their pure form but are blocked by an obstacle (or many). A finned fish is an almost-fish, for example, and things like almost-XY-Wings and almost-Skyscrapers etc are real just like almost-locked-sets. Both their pure and almost-versions are valid structures.

An almost-MUG or almost-UR or almost-BUG doesn't make much sense, though, because DPs are used differently from valid patterns. Their useful strong links are between the plus-candidates only, not between the deadly pattern and the plus-candidates (unless contradiction chains are used). I think of deadly patterns as catalysts that generate strong links between otherwise disconnected candidates.

In your example the MUG generates a strong inference set between the 5r2c2 and the two 9s in r1c9 and r3c4, which can be used in an AIC or a Kraken. The pure MUG is seen nowhere in such verity chains, though. In Nishio chains it can be used as a contradiction condition, of course.

Btw, a very nice MUG solution by Cenoman today.

Well, if you look at the contex of the construct of a deadly pattern

Ab-ab
Ab-ab

The basics would set the extra candidate as true to avoid the 2 slulution state.
Which is how all the unique stuff works.

Almost patterns doesn't have the pattern expressed and usable on its own, instead they are a nested exrpression when combined with other stuff. Which then intern applies the uniqueness deduction. Which is how my mug worked as 2 nested ur states expressed by an external chin.

To me not really confusing but I was around when it was developed... Outside reading it now probably sees it so

StrmCkr wrote:To me not really confusing but I was around when it was developed... Outside reading it now probably sees it so

There's nothing confusing about the uniqueness logic itself. Terms and definitions, and in some ways the usage, have evolved since those times, however. I don't think terms like almost-URs or almost-MUGs etc exist in current terminology, and I see no reason to reintroduce them. The logic you're after is available without such ambiguous terms.