Deadly Patterns & Almost Deadly Patterns

We have to talk about the number of solutions a puzzle can have.

We have to talk about Deadly Patterns.

And finally, we have to talk about Almost Deadly Patterns, which is what we want to talk about, because they form the basis of various powerful Uniqueness Tactics.

This is a long page, and it contains the hardest material on this site.

Take a deep breath.

 

Number of Solutions

The Clues (original Big Numbers) laid out on the Grid determine whether the puzzle has a solution at all and if so, how many solutions.

 

Sudoku:  Unique Solution

A Sudoku is guaranteed to have one and only one Solution. We say it has a unique Solution.

A Sudoku is a puzzle generated by a computer program. As things progress, the program has to check periodically that the puzzle in its current form is OK:

• it does have a solution;
• it does not have two or more solutions.

If the puzzle fails these checks, then it is either modified or just straight-out rejected. So the reason the Sudoku you download from a Web site has a unique Solution is that it is specifically constructed that way.

In what follows, I will use the word puzzle as an umbrella term to designate any one of three things:

• a Sudoku (a single-solution puzzle);
• or a zero-solution puzzle;
• or a multi-solution puzzle.

The last two categories are invalid puzzles; they may look like they're Sudokus, but they aren't.

 

Zero-solution Puzzle

First of all, we need this term, which designates a fatal disaster in the Grid:

• Conflict — a situation on the Grid where some empty Cell has gotten all its candies killed or where two Cells in one House contain equal Big Numbers.

A puzzle is defined by its Clues (original BigNums). Naturally, care is taken that there exist no explicit internal Conflicts within the Clues themselves. But this does not guarantee that the puzzle will have a solution; in fact, it's very easy to produce a solutionless puzzle with very reasonable-looking Clues.

Here's an example of a zero-solution puzzle:

Zero-solution puzzle. In the Upper Left Block, any two of the {59} Cells could be taken as a Locked Pair to cancel both the candies in the third {59} Cell. In Row 6, the {25} {25} Locked Pair forces both the remaining empty Cells in the Row to take on the value 1. In the Middle Left Block, there is no Cell that will accept a 4. An equivalent way of putting this is that the 123567 Locked Set in the six white Cells kills all the candies in the green {25} Cell.

This is fairly representative of what you would find in a typical zero-solution puzzle: straightforward Conflicts. If you don't see them upon doing the initial Candie Markup, they'll crop up soon enough as you proceed.

Obviously, the candie distribution on the above Grid is so complicated that we are not going to derive any bright ideas from it.

But then, how about the following puzzle:  it's been worked down to this point, and only Pair Cells are left — and there are no more moves available. Surprisingly, it has no possible solution.

Zero-solution puzzle involving only Pair Cells. Pick any one of the Pair Cells as a starting point, and choose one of its two candies to be that Cell's final value. This will generate a cascade of moves in the other empty Cells. And you will get a Conflict. (Try it!) So go back to the originally chosen starting Cell and choose its other candie to be the Cell's final value. This again generates a cascade of moves. And guess what? You'll get a Conflict again! This candie pattern is fatal. The puzzle has no solution.

Now, this pattern is not all that simple, but still, it's a lot simpler than the candie distribution in the first zero-solution example. In this case, at least we can say that we're dealing strictly with a collection of Pair Cells. Maybe an idea can be fished out of this.

But first we also have to look at the opposite situation, where we have too many solutions.

 

Multiple-solution Puzzle

Here's a puzzle that has 36 solutions. After working it out as far as possible, you arrive at this:

Multiple-solution puzzle. Look at the nine purple {456} Cells. There are 12 different ways to fill these nine Cells with 4s, 5s, and 6s. And look at the pattern in the orange Cells. There are 3 different ways to fill these seven Cells. (Letting the {123} Cell = 1 or 2 or 3 will give you the three different results.) This puzzle has a total of 12 x 3 = 36 different solutions.

The candie distribution in the above pattern is not as wild as the jumble in the first zero-solution puzzle we saw, but it's still not what you'd call all that memorable.

But of course I've got another example. Again, it's been worked down to this point, and only Pair Cells are left, and there are no more moves available. Sound familiar? Yes, but this one's got two solutions:

Multiple-solution puzzle involving only Pair Cells. Pick any one of the Pair Cells as a starting point, and choose its first candie to be that Cell's final value. This will generate a cascade of moves in the other empty Cells. And you'll get a solution. (Try it!) Then go back to the originally chosen starting Cell and choose its second candie to be the Cell's final value. This again generates a cascade of moves. And guess what? You'll get another solution! For this example, the candie values in each Cell have been artificially arranged so that one solution consists of the first candie in each Cell, and the other solution consists of all the second candies.

So Pair-Cell patterns are subtle. But they're intriguing, and we're going to have a closer look at them.

 

Deadly Patterns

A few years ago, people began to realize that Pair-Cell patterns, like the two we saw above, would be worth checking out. Both of these are examples of so-called Deadly Patterns.

• Deadly Pattern:  a candie pattern that would either cause a puzzle to have no solution at all or cause it to have more than one solution.

A lot of thinking has been done about these patterns, partly to see what they really consist of, and partly to decide what kinds of patterns would actually be recognizable to a human Sudoku player.

A Deadly Pattern would not have to consist of only Pair Cells. However, it turns out that some Deadly Patterns which do consist of only Pair Cells are recognizable directly by a human being. It's because of this recognizability that we concentrate specifically on Pair-Cell Deadly Patterns.

Such patterns are not just a random collection of Pair Cells; there's a considerable amount of inner structure:  they are Interlocked Pair-Cell Patterns, and we need to define that carefully.

 

Interlocked Pair-Cell Pattern

Despite the zero-solution and double-solution Pair-Cell pattern examples presented above, a deadly Pair-Cell pattern does not have to occupy all the empty Cells of the Grid; frequently it occupies only a few Cells. Because of that, we have to define exactly what kind of pattern we're talking about, and we're going to name this an Interlocked Pair-Cell Pattern (don't worry, the common special cases all have shorter names).

(You recall that a House is a Row or a Column or a Block. And you know all about Locked Sets.)

An Interlocked Pair-Cell Pattern is a group of Pair Cells on the Grid which satisfies the following restrictions:

• No candie in the group is a Hidden Locked Single.

• For every House that contains any Cell of the group, the group's Cells in that House form either a Locked Set or several Locked Sets.

• The group is fully move-connected.

And we need to define fully move-connected:

• A group of Pair Cells is fully move-connected if for any two Cells A and B in the group, when you crown either candie in Cell A, there exists a resulting sequence of moves (in group Cells only) which reaches Cell B (and determines its value).

For patterns encountered in practice, it's not hard to see whether they're fully move-connected. The Pair-Cell patterns in the (second) zero-solution puzzle and in the double-solution puzzle we saw above were fully move-connected. The following Grid shows a simpler example:

Move-connectedness. If you take the orange and purple Cells all together as a group, then that group is not fully move-connected. However, the six orange Cells form a fully move-connected group: for example, set the {12} Cell to 1, and from there, there exists a sequence of moves to reach any other orange Cell. Similarly, the four purple Cells form a second fully move-connected group independent of the orange group.

Of course, we can make a stronger statement here. The orange Cells are not just fully move-connected:  they also satisfy all the requirements to be an Interlocked Pair-Cell Pattern — specifically, in each of the three Rows, two Columns, and two Blocks involved, the orange group's Cells form a Locked Set. Similar remark for the purple Cells.

And the Pair-Cell patterns in the (second) zero-solution puzzle and the double-solution puzzle we saw above also satisfy all the requirements of an Interlocked Pair-Cell Pattern. Take the time to check these for yourself.

The definition of an Interlocked Pair-Cell Pattern implies certain properties, and we want to have a look at these.

Within any Interlocked Pair-Cell Pattern:

• Every candie is a Twin (in each of the three Houses its Cell is in).

It's easiest just to check that in one of the examples given above. However, the abstract reasoning is as follows. Consider the N Pattern Cells that happen to lie in some particular House. Since those N Pattern Cells are a Locked Set, their candies are restricted to N different digits. If each of those digits appears exactly twice, that gives 2N candies, exactly enough to fill N Pair Cells. So none of the digits can appear more than twice in a House — each appears exactly twice and is therefore a Twin in that House.  (If you replace "are a Locked Set" by "form several Locked Sets" in that explanation, the argument remains unchanged.)

Now we need to talk about the process of realizing an Interlocked Pair-Cell Pattern. Since the Pattern is fully move-connected, assigning a value to one Cell gives rise to a sequence of moves that reaches any other Cell you want in the Pattern and determines its value. Being optimistic, we might think we could reach all the other Cells in the Pattern this way, determining all their values. If we can really do this, then we will call the resulting Big-Numbered Pattern Cells a realization of the Pattern.

But in fact we already know there's a major issue involved regarding an attempt to realize an Interlocked Pair-Cell Pattern, because we saw a Pattern in the second zero-solution puzzle that could not be realized, since Conflicts began to crop up. Let's have another look at just that Pair-Cell Pattern itself:

Interlocked Pair-Cell Pattern that has no realization. This Pattern looks harmless enough, but no matter which Cell you assign a value to, the subsequent moves in the Pattern will yield a Conflict somewhere.

Any Cell will do to illustrate this; I'll pick one and follow it through:

Interlocked Pair-Cell Pattern that has no realization:  same Grid as above. For example, pick the {12} Cell in the Upper Left Block and say its value is 1. Where the Conflicts arise depends on the order of the moves you make. I did the Middle Center Block last, so the Conflicts arose there. There are two Cells in the Middle Center Block that have gotten all their candies killed. Because of the Conflicts, this Pattern cannot be successfully realized.

But of course, the Pattern in the double-solution puzzle we looked at had two distinct realizations.

So you can see that Interlocked Pair-Cell Patterns represent the two kinds of Deadly Patterns:  zero-solution Patterns, and multiple-solution Patterns.

Thus there are two kinds of Interlocked Pair-Cell Patterns:

• internally consistent — when you assign a value to one Pattern Cell and from that are able to obtain a full, Conflict-free realization of the Pattern, then the Pattern is internally consistent.

• internally inconsistent — when you assign a value to some Pattern Cell and the resulting moves within the Pattern generate a Conflict, then the Pattern is internally inconsistent.

Strictly speaking, this still needs cleaning up: for an attempted realization, we could assign either of two values to the Pair Cell we start with. So we'll get two different realization results. Is it possible to have one fail and the other succeed? No. They'll both succeed, or they'll both fail. We're going to think about why it works out this way.

Internally consistent Interlocked Pair-Cell Pattern:

• An internally consistent Pattern can flip between exactly two Conflict-free realizations.

Why?  Well, the Cell you pick to start the realization process has only two candies, so you can flip (pick one or the other) to try to generate two distinct realizations. What happens in the flipping process? In any House, a 9-candie that was crowned in one realization gets killed in the other realization, but its Twin 9 (in that House) gets un-killed and crowned. In each House, this Twin exchange leaves you with the same set of BigNums in the House, so if one realization was Conflict-free, the other will be too.

(If you're a mathematician, you'll tell me that that description would need a lot more elaboration to turn it into an airtight argument — and you're right. But the description may still be helpful to a Sudoku player.)

Internally inconsistent Interlocked Pair-Cell Pattern:

• Any realization of an internally inconsistent Pattern will have Conflicts.

The argument for that is this:  we've already indicated (above) that if an Interlocked Pair-Cell Pattern has one Conflict-free realization, then it has exactly one other realization, also Conflict-free. That result clearly implies that such a Pattern cannot have one Conflict-free realization and another realization containing Conflicts.

The terminology has now gotten to be horribly heavy. But based on the above results, we can lighten it up considerably:

• Flip-flop:  an internally consistent Interlocked Pair-Cell Pattern.

• Pair-Cell Grave:  an internally inconsistent Interlocked Pair-Cell Pattern.

I think the designation Flip-flop is intuitively reasonable, since it can flip between two different realizations.

As for Grave (as in a place for the dead), that's drawn from a term in widespread use which I will also employ (as you will see below).

Now we want to look at concrete examples of Flip-flops and Pair-Cell Graves.

 

Flip-flop

A Flip-flop has two distinct realizations. It's an internally consistent Interlocked Pair-Cell Pattern.

If a puzzle has no inconsistency problems, then the presence of one single Flip-flop would cause the puzzle to have two solutions. So a Flip-flop is a Deadly Pattern. (If there were three Flip-flops, the puzzle would have 2 x 2 x 2 = 8 solutions.)

The smallest Flip-flop is a 4-Cell pattern involving only two candie values. Because of its shape, everyone calls it a Deadly Rectangle. Its four Corners lie in two Rows, two Columns, and two Blocks (not four Blocks). This implies that it lies entirely in one Band or in one Tower.

Why all these restrictions on the shape? Because the Flip-flop is an Interlocked Pair-Cell Pattern — so its Cells have to form a Locked Set in every Row, Column, and Block it occupies.

This is a Deadly Rectangle:

Deadly Rectangle. This Pattern has two distinct realizations. The candie values are artificially arranged here so that one realization consists of the first candie in each Cell, and the other realization consists of the second candie in each Cell.

This Pattern could not appear in a Sudoku, but it could appear in a two-solution puzzle such as the following (shown as it would appear after all possible moves have been exhausted):

Deadly Rectangle. Since the Deadly Rectangle has two realizations, this puzzle has two different solutions. This puzzle is not a Sudoku.

I've shown the Deadly Rectangle above within a solution-Grid to emphasize its important characteristic: it produces, finally, a puzzle with two solutions. The remaining four Flip-flops we're going to look at would also finally result in a double-solution Grid; but I'm not going to take up the space to keep putting up an example of a full-solution Grid for the remaining Deadly Patterns we look at — at this point we just want to see what the Patterns look like.

Unless you know all this stuff already, maybe you've forgotten that, despite the fact that these Flip-flops cannot appear in any Sudoku, we are ultimately going to connect all this with something (an Almost Flip-flop) that can appear in a Sudoku and can be useful — we just haven't gotten that far yet.

And another point: the Flip-flops we will look at aren't going to be very big. Why? Because we want Patterns that a human Sudoku player can recognize and handle.

So the only additional Flip-flops we'll look at will be 6-Cell Flip-flops; they come in four different shapes.

Here's one of them:

6-Cell Flip-flop with two candie values, occupying 3 Rows, 3 Columns, and 3 Blocks. This Pattern lies within one Tower (it could lie within one Band). It has two realizations: check that for yourself. The candie values are artificially arranged here so that one realization consists of the first candie in each Cell, and the other realization consists of the second candie in each Cell.

Here's another one:

6-Cell Flip-flop with two candie values, occupying 3 Rows, 3 Columns, and 3 Blocks; but this one is bent. It has two realizations.

And here's yet another. Note that even though the 4-Cell Flip-flop could only be constructed with two different candie values, the larger Flip-flops have some incarnations that contain several candie values.

6-Cell Flip-flop with three candie values, occupying 2 Rows, 3 Columns, and 3 Blocks. It lies within one Band (it could lie within one Tower). It has exactly two realizations: check that for yourself.

This is the last one:

6-Cell Flip-flop with three candie values, occupying 3 Rows, 2 Columns, and 2 Blocks. It lies within one Band (it could lie within one Tower). It has two realizations.

That concludes the Flip-flops that we'll look at.

A Flip-flop has two realizations; its presence would cause a puzzle to have more than one solution (provided that the puzzle had any solutions at all).

Now we want to look at the other kind of Deadly Pattern, the kind that causes a puzzle to have no solution at all.

 

Pair-Cell Grave

A Pair-Cell Grave has no realization: it's an internally inconsistent Interlocked Pair-Cell Pattern — it always produces a Conflict within itself.

The presence of a Pair-Cell Grave would cause a puzzle to have no solution at all. So it's a Deadly Pattern.

We've seen one Pair-Cell Grave: it was the candie pattern in the second zero-solution puzzle near the beginning of this page. It contained 12 Cells and didn't have an easy-to-remember shape. In general, Pair-Cell Graves are even bigger than that and have an even more unrecognizable shape.

This lack of recognizability is a problem for the human Sudoku player. A Sudoku can contain an Almost Pair-Cell Grave, which, as its name implies, looks almost like a Pair-Cell Grave, but we need to have some way to be able to recognize these things.

People gave some thought to this years ago and realized that there's one way that a Pair-Cell Grave would be perfectly visible, and that's when it simply consists of a bunch of Pair Cells that occupy all the remaining empty Cells in the Grid. That we could see.

You should be raising two objections to that.

One of them is this:  couldn't the bunch of Pair Cells occupying all the remaining empty Cells turn out to be two (or more) separate Pair-Cell Graves? Oddly, the answer is no. A Pair-Cell Grave is big (it occupies at least four Blocks), and it uses up at least four candie values. To have two separate Pair-Cell Graves on a 9 x 9 Sudoku Grid, they would have to intermingle, and they would be tying up eight candie values, with the result that no possible set of Clues could generate the desired two-Grave pattern. (On a 16 x 16 Grid this wouldn't be a problem, but I'm not doing 16 x 16 Sudokus.)

The second objection revolves around the fact that a final bunch of Pair Cells could be a (rather big) Flip-Flop (we saw one in the two-solution puzzle shown near the top of this page). There is an answer to that too, but it's so heavily tied up with the Almost aspect of Almost Flip-flops that I'd rather deal with it in a separate section at the very end of this page.

I know that was complicated, but it leaves us with a pattern that we can actually recognize. There is a historical term for this pattern. Everyone uses this term, and I will too:

• Bivalue Universal Grave (BUG) — a Pair-Cell Grave that occupies all of the empty Cells on the Grid.

Let's break this down:

• Bivalue — made up of Pair Cells.
• Universal — occupying every empty Cell on the Grid.
• Grave — oh, we are so dead.

We are so dead, of course, because the Grave cannot be realized without Conflicts, and the puzzle has no solution.

This pattern is usually referred to by its acronym, BUG.

A BUG is a Deadly Pattern. A puzzle containing a BUG has no solution.

There are two examples of BUGs below. In each case, I will show only the BUG Cells themselves, and you have to remember that the rest of the Grid is filled with Big Numbers:  the BUG occupies all the empty Cells on the Grid.

This is the smallest BUG you can construct: it has 12 Cells and occupies 4 Blocks, and it needs 4 candie values.

Smallest BUG (12 Cells, 4 candie values). The white Cells all contain Big Numbers (not shown). We've examined this one before, and we found that no matter which Cell you assign a value to, the subsequent moves within the Pattern will yield a Conflict somewhere in the Pattern itself.

Are there other 12-Cell BUGs?  Yes, there's at least one other one, and its Cell distribution is distinct from this one, even taking into account that a Sudoku can have its elements shuffled in certain ways (and its digits can be permuted) to produce a different but logically equivalent Sudoku.  But there are no 11-Cell BUGs.

Typically, BUGs are noticeably bigger than the one above. The following one has 32 Cells. It occupies nine Blocks and uses seven candie values.

32-Cell BUG. The white Cells all contain Big Numbers (not shown). This pattern has no Conflict-free realization.

We've now got two kinds of recognizable Deadly Patterns: small Flip-flops, and BUGs.

And we've finally reached the point where we can make the connection to what you could see in an actual Sudoku.

 

Almost Deadly Patterns

The presence of a Deadly Pattern would cause a puzzle to have either no solution at all or multiple solutions. Since a Sudoku is deliberately constructed to have one single Solution, it cannot contain a Deadly Pattern.

However, a Sudoku can contain something called an Almost Deadly Pattern. We'll see why this turns out to be useful to a Sudoku player.

If a Deadly Pattern is modified by the insertion of one or more extra candies into one or more Cells of the Pattern, then the new Pattern might not be Deadly.  ("might"?  There are restrictions; we'll look at these as we proceed.)  If it's not deadly then it's called an Almost Deadly Pattern. This term is appropriate for two reasons:

• the Pattern is in fact not deadly;

• a Sudoku player can still perceive the Deadly Pattern buried inside the Almost Deadly Pattern.

The extra candies added to the Deadly Pattern to make it no longer deadly are called Heroes: they cure the Pattern, and they save the Sudoku.

Each Hero is like any other candie: it can be true or false (meaning that it can be, or not be, the candie that finally gets crowned in its Cell). All that's needed to prevent the Pattern from becoming deadly is for at least one of the Heroes to be true: if all the Heroes were false (if they all got killed), then the Pattern would degenerate into a Deadly Pattern. Since a Sudoku cannot contain a Deadly Pattern, we have the following result:

• In an Almost Deadly Pattern, at least one of its Heroes must be true.

Maybe I should clarify one thing: I talked about modifying a Deadly Pattern by inserting Heroes into it. Obviously a Sudoku player does not go around inserting extra candies in Cells. Even the Sudoku-generating program does not literally insert extra candies. What I'm talking about is the fact that after Candie Markup has been done (and possibly after many moves have taken place), the Sudoku player may notice on the Grid something that looks like a Deadly Pattern, except that, mercifully, a few Heroes appear in its Cells here and there.

All this blah-blah and no examples, you're thinking.  OK, in the next section we'll start looking at a brief catalogue of Almost Deadly Patterns. But that's all it is at this point — a picture gallery. The Grids below will show what the various Patterns look like and what kind of colour conventions I use to denote Heroes and to highlight certain cells in the Pattern.

Beyond that, you're going to want to know what on earth these things are good for. In the section entitled Applied Examples near the end of this page, I'll point you to a big collection of examples that yield concrete, useful results. But read the rest of this page to get a good grasp on the logical structure of an Almost Deadly Pattern — because understanding that will keep you from making mistakes when you're trying to find a way to exploit an Almost Deadly Pattern in a Grid.

The only Almost Deadly Patterns we'll deal with are Almost Flip-flops and Almost BUGs, because these Patterns are recognizable to a human Sudoku player.

 

Almost Flip-flop  =  Flip-flop+n

The problem with a Flip-flop is that it has two realizations. But if you see something that looks like one of these in a Sudoku, it will in fact be different, because there will be extra candies called Heroes that appear in one or more of its cells. Then it will, in fact, have only one valid realization.

You should be objecting at the top of your lungs:  how can an additional choice result in fewer solutions? Good question. The answer is this:

• A Sudoku is constructed so that the rest of the Grid conspires against the Almost Flip-flop to ensure that in at least one of its Cells the deadly candies both get killed and one of the Heroes lives to be crowned.

It's the rest of the Grid that is designed to wreck the two realizations of the underlying Flip-flop and leave you with a single realization where a Hero emerges as the BigNum in at least one of the Cells of the Almost Flip-flop.

• Because of this required interaction with the rest of the Grid, a Hero in an Almost Flip-flop is some digit which does not equal any of the deadly candies of the underlying Flip-flop.

So let's look at some representative cases.

The smallest Flip-flop is a Deadly Rectangle. There is a widely used name for the Almost version of this, and I will use that name too:

• Unique Rectangle = Almost Deadly Rectangle.

This makes sense. A puzzle that contained a Deadly Rectangle would have multiple solutions. But a Unique Rectangle in a Sudoku has only one realization (and the Sudoku has a unique Solution).

Unique Rectangles occur so often that there is a common abbreviation:

• UR = Unique Rectangle.

The least complex UR is a 1-corner UR. It's a Flip-flop+1:  one of its Cells contains one or more Heroes.  Here's an example:

1-corner UR. The orange Cells are a 1-corner UR in 2,7. (The deadly candies are 2 and 7.) The Hero is the 3 shown in green in one Cell (the "corner"). This Hero must be true to keep the UR from degenerating into a Deadly Rectangle. Result:  we can kill the deadly 2 and 7 in R7C3 (and crown the 3). What's in the Cells in the rest of the Grid doesn't affect the logic in the 1-corner case.

This is a startling result. We've gotten a crowning out of this, and sometimes this gives rise to a long cascade of moves.

Multi-corner URs are useful too, but it takes more work to exploit them.

Here's a 2-side-corner UR; it's a Flip-flop+2:

2-side-corner UR. The orange Cells are a 2-side-corner UR in 3,4. (The deadly candies are 3 and 4.) It has three Heroes (shown in green) in 2 corners on the same side of the UR. At least one of the three Heroes must be true to keep the UR from degenerating into a Deadly Rectangle.

What, no "result"?  Well yes, often there is, but it requires some clever reasoning which depends very much on what's on the rest of the Grid. Ultimately we will look at many examples of this reasoning (as indicated in the Applied Examples section later). But for the moment, all I want is to ensure that you have a firm understanding of the difference between a Flip-flop+n and a BUG+n.

As far as URs go, there are obviously cases other than a 2-side-corner UR. For a 2-far-corner UR, there are Heroes in two diagonally opposite corners. And you can guess what a 3-corner UR is. These will be discussed on the UR page, where I give (many) examples.

A Unique Rectangle is a 4-Cell Flip-flop+n (with n Hero Cells, which we've called corners in the case of a UR). The next biggest Almost Flip-flop is a 6-Cell Flip-flop+n (with n Hero Cells).

A 6-Cell Flip-flop can come in four different shapes, which we saw above in the Deadly Patterns section. A 6-Cell Flip-flop+n obviously occurs in the same four shapes, but we'll only show a couple on this page.

With six Cells, a 6-Cell Flip-flop+n is likely to have Heroes in several of its Cells, so you will probably never have the luck to see a 6-Cell Flip-flop+1, but here's one to look at anyway:

6-Cell Flip-flop+1. The orange Cells are a 6-Cell Flip-flop+1 in 1,3,7. (The deadly candies are 1, 3, and 7.) The Hero is the 5 shown in green in one Cell. This Hero must be true to keep the Flip-flop+1 from degenerating into a pure Flip-flop. Result:  we can kill the deadly 3 and 7 in R3C8 (and crown the 5). What's in the Cells in the rest of the Grid doesn't affect the logic in the single-Hero-Cell case.

This is a striking result, just as it was for a 1-corner UR. Very simple procedure, and we get a Crowning.

But here's a more typical case — a 6-Cell Flip-flop+3:

6-Cell Flip-flop+3. The orange Cells are a 6-Cell Flip-flop+3 in 2,4. (The deadly candies are 2 and 4.) It has three Heroes (shown in green) lying in three different Cells of the Pattern. At least one of the three Heroes must be true to keep the Flip-flop+3 from degenerating into a pure Flip-flop.

And just as for multi-corner URs, getting a result out of this multi-Hero-Cell Almost Flip-Flop takes some work, and that will all be explained on the same page that deals with examples of applied Unique Rectangles.

That's it for Almost Flip-flops. Now we want to look at the other kind of Almost Deadly Pattern.

 

Almost BUG  =  BUG+n

The problem with a BUG is that it has no realization at all: it's internally inconsistent and always produces a Conflict within the BUG itself. But if you see something that looks like one of these in a Sudoku, it will in fact be different, because there will be extra candies called Heroes that appear in one or more of its Cells. Then it will, in fact, have a (single) valid realization.

The mechanism of action in a BUG+n:

• The rest of the Grid is not the key here. There are one or more Heroes in the Almost BUG, and it is these Heroes that provide additional choices that allow the Pattern to have a Conflict-free realization.

In this valid realization, a Hero will be crowned as the BigNum in at least one of the Cells of the Almost BUG, providing the leeway for the Pattern to readjust and avoid internal Conflicts.

• Because the curing process is all internal to the Pattern, a Hero in an Almost BUG is always a digit which does equal one of the deadly candies of the underlying BUG.

The situation with Heroes in a BUG+n is very different from the situation in a Flip-flop+n. In a Flip-flop+n, a Hero could appear in any Cell at all of the Pattern. For a BUG+n, this freedom does not exist — so we want to have a look at that.

For starters, let's look at the 12-Cell BUG we saw in the Deadly Patterns section:

A 12-Cell BUG. To make this a BUG+1, we want to add a 1 or 2 or 3 or 4 Hero to one of the Cells so as to satisfy two criteria: the Hero will not violate the existing Locked Set structure of the Hero Cell's Row or Column or Block; the new Pattern will have a valid realization. There is no Cell in this Pattern where we can satisfy the first criterion! This BUG cannot be converted to a BUG+1.

We're beginning to see that things are not so simple.

We want to talk about the two criteria listed above, but let's do that in the context of a more successful example. I mentioned previously that there's at least one other 12-Cell BUG; here it is:

A different 12-Cell BUG. To make this a BUG+1, we want to add a 1 or 2 or 3 or 4 Hero to one of the Cells so as to satisfy our two criteria: the Hero will not violate the existing Locked Set structure of the Hero Cell's Row or Column or Block; the new Pattern will have a valid realization. Only one Cell satisfies the first criterion:  a 3 could be added to the {12} Cell in the Middle Center Block. And, satisfyingly, putting in that 3 Hero does create a Pattern that has a valid realization. So we have created a BUG+1.

Now, why the first criterion?  Because changing the Locked Set structure of any House of the Pattern would require the addition of yet another empty Cell to the Pattern, with the result that the Pattern as a whole would no longer have an underlying BUG, which would destroy the entire logic of the BUG+1 argument.

For example (in the Grid above), if I tried to add a 3 Hero to the {14} Cell, that wouldn't change the Locked Set structure of its Column or Block, but its Row (which must already contain the BigNum 3 since the three empty Cells in the Row are a 1,2,4 Locked Set) would be messed up:  so I would have to create another empty Cell in that Row — but that would destroy the underlying BUG pattern.

But if I add a 3 Hero to the {12} Cell in the Middle Center Block, this will not change the existing 1,2,3-Locked-Trio structure of its Row, Column, and Block, so the underlying BUG will still be there.

We now have two issues to deal with. One is whether the second criterion above is always satisfied anyway — it isn't, but I'm going to defer the discussion of that for a few minutes.

The other issue is this:  what does the BUG+1 we created above look like in a fully populated Grid?  Like this:

12-Cell BUG+1. In the blue {123} Cell, the 3 is the Hero. Why?  Because if we ignore that 3, then the remaining Pattern is a BUG: every candie is a Twin in every House its Cell lies in. The 3 is a Triplet in its Row, Column, and Block. That's how you find the Hero in a BUG+1. The blue Cell must finally equal 3 in order to prevent this BUG+1 from degenerating into a BUG.

Setting the blue Cell = 3 cracks the Sudoku because the Hero (3) gives the Pattern a Conflict-free realization. Picking the 1 or 2 in the blue Cell would have produced Conflicts.

So for this case, let's look at the cracked BUG+1 (where we picked the 3 Hero in its Cell):

12-Cell BUG+1, realized. The blue Cell has been set equal to its Hero (3), and the resulting moves have been carried out. The realization is, as expected, Conflict-free. The underlying reason for this is that a Sudoku is constructed to have one single Solution.

We deferred a question about whether a proposed Hero satisfying our first criterion always satisfies the second criterion. Let's look at this slightly bigger BUG:

A 13-Cell BUG. To attempt to make this a BUG+1, we would like to add a 1 or 2 or 3 or 4 Hero to one of these Cells to satisfy our usual two criteria: the Hero will not violate the existing Locked Set structure of the Hero Cell's Row or Column or Block; the new Pattern will have a valid realization. Three different Cells satisfy the first criterion:  a 3 could be added to the {14} Cell or to either {12} Cell. But, surprisingly, only one of these three possibilities satisfies the second criterion:  putting a 3 Hero into the {12} Cell in the Middle Center Block does generate a Pattern that has a valid realization.

This example has a very odd twist to it. In any real-world Sudoku which contains the above 13-Cell BUG as an underlying Deadly Pattern, all three of the possible Heroes will in fact appear (in the {14} Cell and in both the {12} Cells)! That means that the Sudoku player will see the Pattern as a BUG+3, and the only known certainty at that point will be that at least one of those Heroes must be true. So how is that handled? See the remarks on a BUG+2 below, and for fully worked-out examples, see the BUG+n page.

What all this shows is that a BUG+n is a subtle construct, and it's amazing that it can occur at all.

Let's wind this down with two final examples. First of all, a BUG+n is typically pretty big, so here's an example of a 32-Cell BUG+1:

BUG+1. In the blue {478} Cell, the 8 is the Hero. Why?  Because if we ignore that 8, then the remaining Pattern is a BUG: every candie is a Twin in every House its Cell lies in. The 8 is a Triplet in its Row, Column, and Block. As noted before, that's how you find the Hero in a BUG+1. The blue Cell must finally equal 8 in order to prevent this BUG+1 from degenerating into a BUG.

As usual, setting the blue Hero Cell = 8 produces a Conflict-free realization of the BUG+1 Pattern, which cracks the Sudoku. Picking the deadly 4 or 7 in the Hero Cell would have produced Conflicts.

We've seen that a BUG+1 yields a Solution with almost no effort at all.

A BUG+n has n Hero Cells. A BUG+n with n greater than 1 is useful too, but it takes more effort to exploit it.

Here's a BUG+2:

BUG+2. Consider the {3856} blue Cell: in that Cell's Block, in its Row, and in its Column, the 5 is a Triplet and the 6 is a Triplet (all the other candies are Twins). So it looks like the 5 and 6 are Heroes. But we have to check the {265} Cell: this time, it's the 5 that's a Triplet in all three of its Houses (the other candies being Twins). So each of the two blue Cells contains candies that qualify as Heroes, which confirms that this Pattern is a genuine BUG+2. At least one of those three Heroes must be true to keep this Pattern from degenerating into a BUG.

All that reasoning is really required: a final pattern with only a couple of non-Pair Cells is not necessarily a BUG+2. An example of that situation will be discussed on the page where BUG+n examples are worked out.

But of course, the conclusion stated on the above Grid shouldn't satisfy you at all. What good does it do to know that at least one of the Heroes must be true?  Well, in fact it does a lot of good; but getting to the big payoff requires some clever reasoning (where have you heard that before?).

So you're tired of waiting. Good. This long intro to Almost Deadly Patterns is done. Now you can comb through a bunch of examples.

 

Applied Examples

There are a lot of these, so they're grouped in two separate pages:

• Unique Rectangle

• BUG+n

Note that the various forms of 6-Cell Flip-flop+n are discussed on the Unique Rectangle page because the ideas involved are very similar.

 

Universal ADP:  a BUG+n, Not a Flip-flop+n

(ADP = Almost Deadly Pattern.)

You don't have to read this section. It answers a question that you might not even care about.

When you have a BUG+n, this final Pattern is universal: it occupies all the remaining empty cells on the Grid. And in the discussion (above) of a BUG+n, it is tacitly assumed that the underlying Deadly Pattern is a BUG, not a Flip-flop (meaning that the underlying Deadly Pattern has no realization, not two realizations). That's true, but do you believe it?

Maybe you don't care, of course, since either kind of Deadly Pattern would be forbidden in a Sudoku, and the presence of one or more Heroes would fix either one of them up.

But if you do care, then you might like to know that this final universal-empty-Cell Almost Deadly Pattern is in fact a BUG+n, not a Flip-flop+n.

The next time you end up with an apparent BUG+n in all the empty Cells, make a photocopy. On the copy, kill all the Heroes. Pick any Pair Cell and crown either candie in it. Make the subsequent moves — and you will always get Conflicts within the Deadly Pattern itself. (So the underlying Deadly Pattern is a BUG, not a Flip-flop.)

That's one way of answering the question. Here's another. Suppose that there is a big, multi-Cell Flip-flop+n Pattern in the Sudoku we're working, and that some mystic sixth sense guides us to avoid wrecking this Pattern as we proceed. Finally, we wind up with only the big Flip-flop+n left in all the empty Cells, and the Grid looks like this:

Here, the final universal Almost Deadly Pattern is a Flip-flop+n. Oops — looks like we forgot to do a bit of updating as we were going along! Notice the blue Big Numbers. Now do the neglected updating, and make any obvious moves. The Flip-flop+n will evaporate.

Nobody is going to fail to do updating like that. That's why a final universal Almost Deadly Pattern is never going to be a Flip-flop+n. It will be a BUG+n.