Chain

Preliminary Remarks on Attack Chains

To make the Sudoku Grids look right, make these two settings if they exist:

  • View/TextSize =
    Medium or Normal

  • View/Zoom =
    100% or Reset

Or read Viewing This Site.

 

Definition of an Attack Chain

Why the qualification Attack Chain?  Because we will spend most of our energy on finding a Chain we can use to attack some Worthy Target on the Grid.  (Later on, we'll see a completely different kind of entity called a Target Chain, which of course is something that will be the victim of an Attack Chain that we construct.)

I could be very top-down about all this and give, right away, a full definition of an Attack Chain with all the bells and whistles.  But I'm going to cheat:  the definition below is really that of a Pair-Cell Chain, which is the simplest thing to think about. This will get us off the ground, and in a later section (The Cell-to-Cell Driving Force in an Attack Chain), we'll talk about more sophisticated Attack Chains.

So for the time being we'll define an Attack Chain as follows:

An Attack Chain is a sequence of Cells where —

So the sequence of Pair Cells

{25} {51} {17} {73} {32}

would not function as a Chain if the 2 were assumed crowned in the first Cell, but it would function as a Chain if the 5 were assumed crowned:

{25} {51} {17} {73} {32}

We don't actually do all these Kills and Crownings on the Grid. We just observe the fact that if the first Cell were a 5, then the last Cell would be a 2.

At this point, it's completely unobvious what good such a Chain is. Attack Chain?  Say what?  Right.  But we're going to see that a Chain like this, along with its associated if/then argument, is going to allow us to construct a proof that some particular candie on the Grid is false — so that it can be killed. (The Chain is part of the proof; often there are other parts needed to make the total proof complete).

 

Remark on Logic

When you want to find an Attack Chain which shows that, under the assumption that gets the Chain going, some particular target candie on the Grid gets killed, you try to construct such a Chain by trial and error. You might succeed. But in the process, you may also find Chains that show the reverse, that the target candie gets crowned. What you will do is retain only the Chain that shows what you want(!!).

This situation may seem very disconcerting. But it arises from the fact that often the assumption that starts the Chain is in fact false, so that anything whatsoever could be derived from it.

We will not just sweep this problem under the rug. The manner in which the overall logic is justified will be explained in the sections on Wrong Chains and Gotcha Chains. In addition, if it still bothers you, there's a longer discussion of this issue in the last section on this page (Digression on Logic).

 

Marking Up an Attack Chain

If you scroll down and look at any of the example Grids below, you'll see that the Attack Chain Cells are labelled A, B, C, . . .

You will find it convenient to use coloured pencils (which you can buy at any stationery store) to write in the letter labels of a Chain (if doing so appeals to you). For a Directed Attack Chain, you can circle the intended victim in colour. This additional markup in a pastel colour stands out, but it doesn't get confused with the main markup (the candies) on the Grid.

 

The Three Ideas Involved in Constructing an Attack Chain

We want to construct an Attack Chain as part of an argument that some candie in some Cell must be false, so that it can be killed.

In doing this, there are three completely separate issues involved —

Because these are all complicated issues, I don't want to deal with them simultaneously, so we'll whittle away at them one by one.

The third item, the choice of a Worthy Target, is in fact the first thing that preoccupies you when you're thinking about constructing an Attack Chain.  But that choice is so complex that I have to discuss it last, not first.

 

Attack Chains:  the Different Layouts

Chains exist implicitly on the Grid, and we have to find them. The layout of a Chain refers to its configuration on the Grid. Practically speaking, Attack Chains fall into two groups:

In this section, we'll examine the various kinds of Attack Chains that fall into these two groups. At this point, our remarks will be restricted to conceptual descriptions. Then in a later section, full-Grid examples will be given.

 

Directed Attack Chain

We need these basic terms:

If we know that a candie is false, then we can kill it.

For a Directed Attack Chain, we have some specific Cell, and in that Cell we have a specific candie that we want to try to prove false, because we have already done some work to determine that that candie is a Worthy Target.  Oddly, we don't know in advance whether that candie is in fact false(!). So we embark on a trial-and-error process to construct an Attack Chain that proves that the candie must be false.  (If we fail, we give up and work on some other candie, which may be in the same Cell or in a different Cell.)  When we "construct" the Chain, of course, we are just formally recognizing its existence on the Grid; but sometimes the Chain turns out to be fairly long and complex (which is why we put letter labels in its Cells).

There are two kinds of Directed Attack Chains:

We'll define these in the next two sections.

 

Wrong Chain

Related external ideas:  forbidding chain, discontinuous nice loop.

We need this term, which designates a fatal disaster in the Grid:

If we were to hypothetically assume that some candie is true and then find out that that assumption leads to a Conflict, we would know that that candie must be false. (A correct assumption would not have led to any Conflicts.)

The situation is this:  we have have done an analysis that tells us that the candie we want to kill is in fact a Worthy Target. So we will try to construct an Attack Chain to demonstrate that the assumption that the candie is true will lead to a Conflict. If we succeed in doing that, the Chain we've constructed is called a Wrong Chain, and we've earned the right to kill the candie.

If we don't succeed in finding a Wrong Chain, we've learned nothing. So we would go to work on some other promising candie.

(At this point, I haven't yet explained how we would know that the given candie would be a good one to attack; this issue will be dealt with in the long section below entitled The Choice of a Worthy Target)

The following is a bare-bones example of a Wrong Chain:

Wrong Chain to prove the 4 in Cell A is false.

Assume that Cell A = 4.

Follow the Chain ABCDEF.

You will find that F = 4.

That's a Conflict: two 4s in Row 1.

So the 4 in Cell A can't be true, and we can kill that 4.

That's nice. But where did those neatly coloured and labelled Cells B,C,D,E,F come from? You had to find them. That takes work (but it's probably the most enjoyable part of doing Sudokus). Do you colour them green? No. Do you label them with capital letters? You probably will if you've got a long Chain where labels will facilitate the checking process — you do want to recheck the Chain to make sure you did it right!  (I use light-coloured pastel pencils for labelling Attack Chain Cells.)

And the story's worse than that. When you temporarily assumed that the 4 in Cell A was true and started making Chains, you almost certainly found some Chains that did not seem to give a Conflict. For example, you might even have found a Chain concluding that Cell F = 9! What are you supposed to make of that? Simple:  you're hoping the 4 in Cell A is false — but if it is, then the rules of logic tell you that you can wind up proving absolutely anything whatsoever from the (wrong) assumption that A = 4. But how does all that tell us that the procedure we're using is OK?

It is OK:  if the 4 in Cell had been true, then we would not have been able to construct any Wrong Chain starting from that assumption. One single Wrong Chain suffices to show that the 4 in Cell A is false.

But then of course there's more bad news. In a real Grid, you have no idea whether the candie you've picked to work on is in fact true or false. All you know is that if it is false, then killing it will probably produce a cascade of moves (because it was a Worthy Target, which is a subject we have yet to discuss). But if in fact the candie not false, then you won't be able to construct a Wrong Chain (but you still won't know whether the candie is true or false). This means that when you get nowhere trying to construct a Wrong Chain for some candie, you should try targeting a different candie (possibly in the same Cell).

What's the upside? Well, finding a Chain that works is more fun than anything else, and you eventually do get better at it.

Here's a second example, and it's a little different:

Wrong Chain to prove the 4 in Cell A is false.

This really is different: our assumption is going to produce a remote Conflict.

Assume that Cell A = 4.

Follow the Chain ABCDEF.

If you're lucky you'll notice that Cells B and F both equal 2.

That's a Conflict: two 2s in the Upper Right Block.

So the 4 in Cell A can't be true, and we can kill that 4.

You can't aim for finding a remote Conflict; you're lucky if you even see it. But if you do see it, then you know the assumption was false, and you've got a Wrong Chain.

You might ask, wouldn't it have been possible here to construct a Wrong Chain like the one in the preceding example, where you reach a 4-Cell in direct Conflict with the original Cell? Quite possibly, but so what? A Conflict's a Conflict, and that's all you need.

 

Gotcha Chain

Related external idea:  xy-chain.

Again, the situation is this:  we've done some work to determine that some specific candie is a Worthy Target. Suppose that the candie we're trying to kill is a 9. Then we will try to construct an Attack Chain (which does not include the targeted Cell) that's like a two-headed serpent. Both ends of the Chain see the Cell with the 9 we're attacking, and in fact each end of the Chain contains a 9 candie. What we want is this: if one end of the Chain is not 9, then the other end is 9. So the 9 we're attacking can't get away: if one end of the Chain doesn't kill it, then the other will. Keep that description in mind when you're trying to put together a two-headed Chain like this. If you succeed in constructing such an Attack Chain, it's called a Gotcha Chain, and you've earned the right to kill the targeted candie.

If we don't succeed in finding a Gotcha Chain, we've learned nothing. So we'd go to work on some other promising candie.

This is a schematic example of a Gotcha Chain:

Gotcha Chain to prove the 9 in the purple Cell is false.

Cell A can only be 9 or 7.

If A = 9, it kills the 9 in the purple Cell.

Or if A = 7, then follow the Chain ABCD:  you'll find that D = 9, and that kills the 9 in the purple Cell.

There were only two possibilities, and for both of them we find that the 9 in the purple Cell dies. So we can kill the 9 in the purple Cell.

Gotcha!

(This Gotcha Chain in 9 works just as well the other way around too: start from end D, and follow the Chain DCBA — you'll reach the same conclusion.)

Now if you compare the first Wrong Chain example to this Gotcha Chain example, you'll see that the two ideas are logically equivalent. However, psychologically the two procedures feel different, and you will probably develop a tendency to favour one or the other approach.

The remarks following the first Wrong Chain example (above) also apply here, generally. For example, in the process of trying to put together a Gotcha Chain, you assumed some candie was (hypothetically) true to start the Chain; if that candie was in fact false, you could wind up showing some weird things when you're trying to construct the Chain: ignore them, and concentrate on trying to reach another Cell that will contain a candie that will kill the targeted candie.

The logic is strange but correct. Above, we assumed A = 9 or A = 7, and we constructed an argument from each assumption showing that the 9 in the purple Cell gets killed. But of course, one of our two assumptions is not true, so that one of the two arguments is garbage. This is not a problem: both arguments say that the 9 in the purple Cell gets killed, and one of those arguments is right. That's all we need.

And as usual, you don't know whether the targeted candie is true or false. If in fact it's not false, then you will not be able to construct a Gotcha Chain (but you still won't know whether the candie is true or false). This means that when you get nowhere trying to construct a Gotcha Chain for a candie, you should try targeting a different candie (possibly in the same Cell).

That's it for Directed Attack Chains. Now we want to look at the other kind of Attack Chain.

 

Aimless Attack Chains

For an Aimless Attack Chain, we do not have a specific candie that we want to prove false:  we have no Target. Rather, the layout of the Chain is so simple that it'll be recognizable if it occurs — so we undertake an extensive trial-and-error process to find a Chain with this simple layout. The Chain has the property of killing a certain candie-value in the Cells in its Target Area. But of course that candie-value may or may not appear in the Target Area — if it does, we've lucked out, and if we're even luckier, the Kill gives rise to some new moves.

In the next three sections, we'll talk about three kinds of Aimless Attack Chains:

 

3-Pair-Cell Chain

External synonym:  xy-wing, y-wing.

You recall that a House is a Row or a Column or a Block.

If, in any House, you find two Pair Cells {ab} {bc} with one candie (b) in common, then you will check to see whether either of these Cells sees a Cell {ca} lying outside that House. If such a Cell exists, then you've got a 3-Pair-Cell (Gotcha) Chain:

You will wind up with either a 1-Cell Kill Area or a 5-Cell Kill Area.

Here's the first type, with the small Target Area:

3-Pair-Cell Chain.

If Cell A = 2, then that would kill any 2 in the yellow Cell.

Or if Cell A = 7, then Chain ABC implies that C = 2, which again would kill any 2 in the yellow Cell.

Since Cell A must equal 2 or 7, we conclude that we can kill the 2 in the yellow Cell.

ABC is a Gotcha Chain in 2, but it was aimless:  we didn't pre-choose the target — we didn't even know whether there would be a 2 in the Target Area.

Here's the second type, with a bigger Target Area:

3-Pair-Cell Chain.

If Cell A = 1, then that would kill any 1s in the yellow Cells.

Or if Cell A = 3, then Chain ABC implies that C = 1, which again would kill any 1s in the yellow Cells.

Since Cell A must equal 1 or 3, we conclude that we can kill any 1s in the yellow Cells.

ABC is an (aimless) Gotcha Chain in 1.  The Yellow Cells are the Cells which both ends of the Chain see.

(Note on finding: either you saw the {35} {51} in the Row and then looked for the external {13}; or you saw the {13} {35} in the Block and looked for the external {51}.)

3-Pair-Cell Chains are not rare. But they are Aimless Chains, meaning that you don't know whether or not there will be any killable candies in their Target Area.

Scouring the whole Grid to find a 3-Pair-Cell Chain can be fairly exhausting. In principle, you'll check each Row, Column, and Block for two Pair Cells of the form {ab} {bc} and then check for the needed external Cell {ca}. You can learn to do this with no redundancy in the search by checking only oblique Pair Cells in the Blocks, so that you don't re-do any of the checks done on the Rows and Columns.

For that matter, you'll decide whether to use this aimless approach at all or instead to look for a Directed Chain (a Gotcha Chain or a Wrong Chain). I avoid using Aimless Chains, because I want the satisfaction of finding a Worthy Target and then constructing a Directed Attack Chain to demolish that Target. But you will have your own preferences in the matter.

 

Same-Pair Chain

External synonym:  remote pair chain.

A Chain of identical Pair Cells is very obvious on the Grid. If it contains an even number of Cells, it's a double Gotcha Chain — a Gotcha Chain in either of its candies.

When one of these occurs, it usually has 4 Cells.  6-Cell Same-Pair Chains also occur, but less frequently.

The Kill Area can consist of 1 or 6 Cells.

Here's the first type, with a small Target Area:

4-Cell Same-Pair Chain.

Look at Chain ABCD.

If A = 1, then D = 2.

If A = 2, then D = 1.

A and D both see the yellow Cell.

So any 1 or 2 in the yellow Cell is killed.

ABCD is a Gotcha Chain in 1, and it's also a Gotcha Chain in 2 (but it's aimless — you don't know if there'll be any victims or not).

When a Same-Pair Chain like the one shown above occurs, most of the time there are no killable candies in the one-Cell Target Area. But of course a Chain like this is very easy to see and it's very easy to check its Target Area.

There's an important point to make:  AB is a Locked Pair which produces a bunch of Kills; same for BC and CD. It is assumed that you've already applied those. Any Kills produced by the two ends of the Gotcha Chain are over and above the the Locked-Pair Kills.

Here's the second type, with the big Target Area:

4-Cell Same-Pair Chain.

Look at Chain ABCD.

If A = 2, then D = 7.

If A = 7, then D = 2.

A and D both see the yellow Cells.

So any 2 or 7 in the yellow Cells is killed.

ABCD is a Gotcha Chain in 2 and in 7.

But ABCD is also a (Column-Based) Sashimi in 2 and a Sashimi in 7, so you probably caught it that way already. (See 2-Fish.)

When you see a 4-Cell Same-Pair Chain like the one above, it's more likely to produce a Kill, because of the larger Target Area.

Here's a 6-Cell Chain:

6-Cell Same-Pair Chain.

Any 1 or 7 in the orange Cell is killed by the 6-Cell Chain ABCDEF.

Any 1 or 7 in the yellow Cell is killed by the 4-Cell Subchain ABCD.

Any 1 or 7 in the pink Cell is killed by the 4-Cell Subchain BCDE.

Think I missed something?  No — any other Kills you see are produced by the Locked Pairs AB or BC or CD or DE or EF, and presumably you've already carried those out.

6-Cell Same-Pair Chains are fairly rare, but when you do see one, you also have to check the Kills produced by the 4-Cell Subchains, as indicated above. Unfortunately, there are usually no Kills at all.

 

Little ALS Chain

External synonym:  xyz-wing.

Up until now, the Attack Chains we've looked at have all been composed only of Pair Cells. But now we're going to look at a Little ALS Chain, which is a 3-Cell Aimless Gotcha Chain that contains an Almost Locked Set.

If, in some Block, we find the 2-Cell Set

{129} {12}

we note that this is not quite a Locked Pair — but if something would just kill that 9 for us, we'd have {12} {12}, which would result in some Kills in the rest of the Block.

In the following Grid, there occurs a third Cell (labelled A), which contains the needed 9, along with one of the other two candies involved (a 1 in this example). If you've never seen this discussed elsewhere, then you'll never guess that the three green Cells constitute a Gotcha Chain, but they do.

Little ALS Chain.

If Cell A = 1, then that would kill any 1s in the yellow Cells.

Or if Cell A = 9, then Cells B B would become the Locked Pair {12} {12}, which again would kill any 1s in the yellow Cells.

Since Cell A must equal 1 or 9, we conclude that we can kill any 1s in the yellow Cells.

ABB is a Gotcha Chain in 1.

Note that the two Cells B B are given the same label because they work together as one functional unit.

Here's a similar example, where the external Cell (A) now contains a {29}:

Little ALS Chain.

If Cell A = 2, then that would kill any 2s in the yellow Cells.

Or if Cell A = 9, then Cells B B would become the Locked Pair {12} {12}, which again would kill any 2s in the yellow Cells.

Since Cell A must equal 2 or 9, we conclude that we can kill any 2s in the yellow Cells.

ABB is a Gotcha Chain in 2.

To find a Little ALS Chain, you always start by looking for an Almost Locked Set of the form {ab} {abc} in a Block. Then you check for the existence of an external {ac} or {bc}.

Little ALS Chains don't occur too often (and they don't always kill anything), so you have to decide whether and when you think it's worth looking for one.

There will be more remarks below on the occurrence of an Almost Locked Set inside an Attack Chain in the general case.

That's it for all the types of Attack Chains that I will cover, both Directed and Aimless.

Now we want to beef up our ideas about the ways that we can be propelled from one Cell to the next as we traverse a Chain.

 

The Cell-to-Cell Driving Force in a Chain

Up till now, almost every Attack Chain we've looked at has been a sequence of Pair Cells, where each move created a (Naked) Locked Single in the next Cell of the Chain.

This constitutes a very simple driving force propelling us through the Chain — it's simple, and we like it. But in fact, there are several possible driving forces, and we want to look at these four, listed in order of increasing difficulty:

 

Pair-Cell Attack Chain

Related external idea:  xy-chain.

No surprise here. This looks just like most of the examples above.

Pair-Cell Attack Chain.

(This is a Gotcha Chain in 9.)

If A = 9 then the 9 in the purple Cell is killed.

If A = 7, look at the Chain ABCDE: E = 9, so the 9 in the purple Cell is again killed.

The simple moves between Pair Cells we're so used to drives the motion through this Chain.

Note the back-and-forth motion that occurs from C to D to E. A Chain can wander all over the Grid, and it can criss-cross itself.

The next example is also just a Pair-Cell Chain, but it involves a cumulative effect (there's nothing unusual about this — it occurs frequently in normal play, not just in Chains).

Pair-Cell Chain; cumulative effect.

(This is a Gotcha Chain in 8.)

If A = 8, then the 8 in the purple Cell is killed.

Or if A = 7, then follow Chain ABCD:

B = 3.

C = 9.

D = 8 because of both B and C.

Cells B and C have a cumulative effect on Cell D.

OK, that was easy. Now we want to look at the other three mechanisms that act as driving forces.

 

Attack Chain Containing an ALS (Almost Locked Set)

This is something that occurs quite frequently. In addition to single Cells in an Attack Chain, there can also be a group of Cells. The group will be an Almost Locked Set (ALS), and the action of the preceding Cell in the Chain will convert that Almost Locked Set into a genuine Locked Set. That in turn will have an effect on the next Cell in the Chain.

Here's an easy example:

Attack Chain containing an ALS.

(This is a Gotcha Chain.)

Either A = 4 or A = 2.

If A = 4, then the purple Cell's 4 will be killed.

Or if A = 2, then follow Chain ABCDD:

A = 2, B = 7, C = 9.

DD becomes a 3,4 Locked set (because of C), which kills the purple Cell's 4.

Since Cell A must equal 4 or 2, we conclude that we can kill the 4 in the purple Cell.

It was remarked above that a Gotcha Chain also works the other way around. The Gotcha Chain we just looked at ended in an Almost Locked Set; let's see how we can apply the necessary logic to start that Chain from its other end.

This is the same Grid as above, but the Cells have been re-labelled:

Same Grid as above.

Gotcha Chain (re-lettered in the other direction) now starts with an ALS.

Either one of the Q Cells = 4,
or neither Q Cell = 4.

If one of the Q Cells = 4, then that kills the purple Cell's 4.

Or if neither Q Cell = 4, then follow the Chain QQRST:

Neither Q = 4, so QQ becomes a 3,9 Locked Set, which kills the 9 in R.

So R = 7, S = 2, T = 4, which kills the purple Cell's 4.

Of the carefully chosen pair of statements

one has to be true and the other false, so we are covering a complete set of possibilities. These two possibilities are then seen to imply the same result, so that result must be true.

Make sure you understand the logic of that Chain. Why? Because when you read people's ideas on Chains on the Internet, someone will pull a trick like that, starting off from an Almost Locked Set, and you will want to think, Yes, I've done that before.

Here's a different example — a long Chain with a big Locked Set in the middle of it:

Attack Chain containing an ALS.

(This is a Wrong Chain.)

If A = 7 then we have the following:

B = 6, C = 5, D = 7.

EEEE becomes a 2,3,4,5 Locked Set (because of D).

F = 7 (because of the 2,3,4,5 Locked Set EEEE).

G = 6, H = 5, I = 7.

That's a Conflict (two 7s in Column 5).

So the 7 in Cell A can't be true, and we can kill that 7.

That was harder.

Not all Chains need this added gimmick, but when you do need to incorporate an Almost Locked Set, doing so can make it possible to prove things you can't prove any other way.

But you're human, of course, and if this stuff is new to you, that last example probably just made your eyes glaze over. Reading somebody else's Chain is like watching someone play the piano — you know you can do it better yourself. That's the way it is. As soon as you've read enough of this page to know why you'd want to construct a Chain, print out some candie-marked hard Sudokus and work on Chains (after going through the basic logic). Try to notice when you've (inadvertently) created a new Locked Pair or Locked Trio, and exploit that fact. That'll give you a lot more satisfaction than just reading examples.

I will present more examples, of course, given my incurable verbosity.

 

Attack Chain Containing a Hidden-Locked-Single Crowning

Related external idea:  discontinuous nice loop.

The Attack Chain in the preceding example occupied 12 Cells. There is a way of cutting that down, but it requires close attention.

This is an example of that approach:  it depends on the fact that if a move in the Chain kills some candies in a House, it can happen that some candie in another Cell suddenly becomes a Hidden Locked Single — so you can crown that candie in the next move in the Chain.

In the three Hidden-Locked-Single Crownings that occur in this example, all of them result from killing one Twin in a House, which immediately turns the surviving Twin into a Hidden Locked Single. So the Crownings here are in fact Surviving-Twin Crownings; this situation occurs frequently.

The notation used in the Grid below assumes that you've read the page on Twin Tagging.

Wrong Chain containing some Hidden-Locked-Single Crownings.

Same Grid as in preceding example.

Assume A = 7 (so A is not 5).

Bs = 5 (sole surviving 5 in the Row).

C = 7.

D is not 7.

Es = 7 (sole surviving 7 in the Block).

F is not 7.

Gs = 7 (sole surviving 7 in the Block).

That's a Conflict (two 7s in Column 5). So Cell A can't equal 7, and we can kill that 7.

Why did I put the BigNums in certain Cells? Just so you would believe the fact that the indicated Twins really are Twins.

Why the labelling notation Bs, Es, Gs?  You can take the added s to mean Hidden Locked Single.

Because this example is hard to follow, I've grayed out the candie in each Cell which is hypothetically killed as you go through the Chain. (Normally I don't do that, since a real Grid won't do that for you.)

This Chain is only about half as long as the one in the preceding example. This conciseness is gained, however, at the cost of having to pay very close attention to what you're doing. And of course, the preceding example shows that for any Chain-move which is a Hidden-Locked-Single Crowning, you can replace that move with several moves that involve only Pair Cells and embedded Almost Locked Sets.  For that reason, I will not give any more examples using Hidden-Locked-Single Crownings on this site. But if you like this gimmick, it's definitely usable, and in any case you have to be aware of this Tactic, as you'll run across it frequently on sites that deal with Chains.

 

Attack Chain Containing an Almost Claim

Related external ideas:  hinge, empty rectangle.

In constructing an Attack Chain, you may kill some candies that create a new Claim in some nearby Cells, and that Claim may then produce a useful Kill that allows the Chain to continue.

This situation is not terribly easy to recognize, so we'll start with an example whose form is well known — you'll see it on various web sites, where it's called a Hinge:

Attack Chain containing an Almost Claim (a Hinge).

(This is a Wrong Chain.)

Assume A = 2.

BBB now contains no 2s.

CC's two 2s become a Block-on-Column Claim in 2 (because of BBB), which kills the 2 in Dc.

Dc = 3, E = 4, F = 2, which is in Conflict with A = 2.

Therefore A can't be 2, and we can kill that 2.

Note that the Kills in BBB at first seem utterly useless: BBB becomes {45}{56}{67}, and what are we supposed to do with that? Well, the killed 2s in BBB are auxiliary Kills: since BBB now contains no 2s, this fact sets up the 2s in CC to become a Block-on-Column Claim in 2.

As regards the labelling notation Dc, you can take the added c to mean Claim.  (The 2 in Dc was killed by a Block-on-Column Claim.)

And because this example is again one that's hard to follow, I've grayed out the candie in each Cell which is hypothetically killed as you go through the Chain.

That example (which generated a Block-on-Column Claim on the fly) is called a Hinge because of the change of direction of action from horizontal to vertical in the Upper Right Block.

The other kind of Almost Claim (which generates a Column-on-Block Claim on the fly) has no generally accepted name, but I could suggest Trigger.  This is what it looks like:

Attack Chain containing an Almost Claim (a Trigger).

(This is a Wrong Chain.)

Assume A = 2.

B now does not contain a 2.

CCC's three 2s become a Column-on-Block Claim in 2 (because of B), which kills the 2 in Dc.

Dc = 3, E = 4, F = 2, which is in Conflict with A = 2.

Therefore A can't be 2, and we can kill that 2.

Note, again, that the killed 2 in B is an auxiliary Kill.  B now equals {56}, but we don't care about that: what we care about is that B no longer contains a 2 candie, and that fact sets up the 2s in CCC to become a Column-on-Block Claim in 2.

You probably won't use an embedded Almost Claim very much, because they're not easy to see:  you have to notice the auxiliary Kill and the fact that a new Claim is formed.

On what kind of a Grid does an Almost Claim embedded in an Attack Chain become a more likely Tactic?  On a very difficult Grid where, after the usual Tactics, you still have a lot of Cells that contain lots of candies. A Grid like that can be extremely hard to solve, and allowing the inclusion of an Almost Claim in a Chain can give you an increased chance of finding a useful move.

Additionally, Attack Chains that allow embedded Almost Claims (as well as embedded ALSes of course) constitute a Tactic that is logically equivalent to a Tactic that you will see referred to as the "almost locked sets" technique. I don't cover that on this site because I would rather think in terms of Chains as outlined on this page, but you will find some additional remarks on that technique at the end of the Links page.

 

The Choice of a Worthy Target

You've been very patient. Finally, we're at the point where we can look at some full-Grid examples. And at last we're going to look at the reasons why we think that being able to kill some specific candie would be a really helpful thing to do:  we're going to look at four categories of Worthy Targets.

Some specific candie constitutes a Worthy Target if we have reason to believe that killing that candie would unleash a cascade of Kills that would crack the entire Sudoku or at least substantially clean up the Grid.

In the next four sections, we'll look at the following kinds of Worthy Target —

If we have found a Worthy Target, we attempt to construct a Directed Attack Chain — a Wrong Chain or a Gotcha Chain — to crack that Target.

But there can be a much less satisfying situation. In a really disastrous Grid where there does not exist a Worthy Target, we have no promising candie to attack. In that case, we may or may not choose to continue. If we want to keep going, then we have to look for an Aimless Attack Chain that will kill something somewhere, even if the resulting Kill produces no perceptible advantage. We'll consider that (desperate) case in the following section:

The hope, of course, is that if we keep whittling down the Grid, the Sudoku might eventually crack, or conceivably a Worthy Target might finally be created.

 

Fault Point

A Fault Point is a Twin-based concept.  From reading the page on Twin Tagging you recall what Twins are:

(A House is a Row or a Column or a Block.)

Recall that any candie can have at most 3 distinct Twins:  a Row Twin, a Column Twin, and an obliquely located Block Twin.  In general, a candie will have 0, 1, 2, or 3 Twins, and that number is called the candie's Twin-link Degree.

A Fault Point is a Pair Cell where each of the two candies in the Cell has a high Twin-link Degree.  The Fault Point's Twin-link Degree is just the ensemble of the Twin-link Degrees of the Cell's two candies.  Specifically, a decent Fault Point will have a Twin-link Degree of (3,3) or (2,3).

The point of this is that a Fault Point is very heavily linked into the Grid:  if you kill one of its two candies, all the Twins of that candie get crowned(!), and of course the Fault Point's unkilled candie gets crowned, which means that all its Twins get killed.  That's a very big effect — often the resulting cascade of moves will crack the entire Sudoku, or at least the Grid will be cleaned up substantially.

For that reason, a Fault Point is a Worthy Target, so it's worth trying to construct an Attack Chain to kill one of its candies.

The notation used in the Grid below is defined in the page you've read on Twin Tagging.

This is an example of an Attack on a Fault Point:

Gotcha Chain to crack a Fault Point.

The purple Cell is a (3,2)-Degree Fault Point: the 4 has three Twins, and the 8 has two (look and verify that for yourself).

That means the purple Cell, being highly connected to the rest of the Grid, is a Worthy Target, so we'd like to crack it. We don't know which of the two candies to attack, but we'll try the 8.

Gotcha Chain: if A = 8, the purple Cell's 8 dies; or if A = 7 then D = 8, and again the purple Cell's 8 dies. So we can kill the 8 in the purple Cell, and crown the 4.

After that, the rest of the Sudoku falls apart easily.

The catch, as usual, is that we don't know which of the two candies in the Fault Point is the right one to try to attack. But that's an inherent difficulty with Wrong and Gotcha Chains.

In attacking a Fault Point, it's not absolutely necessary to attack that Cell itself. In the following example, we attack a Cell that's so closely linked to the Fault Point that if the attack works, the Fault Point will be determined (which is all we need):

Wrong Chain to attack a Cell which is a closely-linked neighbour of a Fault Point.

The yellow Cell is a (3,3)-Degree Fault Point: each of its two candies has three Twins.

If we can succeed in knocking off the 4 in Cell A, then clearly the 2 in the Fault Point will be killed, and we're in business.

And in fact, we find the Wrong Chain ABCDEF: if A = 4, then F = 4, which is a Conflict — two 4s in Row 4. So we can kill the 4 in Cell A.

That causes the yellow Fault Point to take on the value 8, and the subsequent moves easily crack the Sudoku.

The next example is another optimal Fault Point example (optimal meaning that the Fault Point's Twin-link Degree is (3,3), which is maximal).

But it's also a concrete example of a Wrong Chain that produces a remote Conflict.

Wrong Chain to crack a Fault Point.

Cell A is a maximal-Degree Fault Point: both its candies have three Twins.

We'll try to construct a Wrong Chain to kill the 4 in A.

In the process of fumbling around trying to construct a Wrong Chain from A, we construct ABCDEF and (luckily) we notice that both B and F equal 2. That's a Conflict — two 2s in the same Block. That means that A can't equal 4.

Remote Conflicts always occur by accident; you might not notice one, but if you do, your reasoning is done.

The bottom line is that the 4 in the Fault Point is killed, and the 2 is crowned. That cracks the whole Sudoku.

Incidentally:  could we have found a conventional Wrong Chain here? Yes, in this case we could. Look for it; it's not hard to find (ABCDE is the beginning of it). It's just that if you happen to find a remote Conflict, you don't really have to go any farther.

The above examples might give the impression that it's easy to find a Wrong Chain or a Gotcha Chain to attack a Fault Point, but in fact that's often not the case. The following example shows a more difficult Chain, which is more typical. This particular Wrong Chain involves an Almost Locked Set:

Wrong Chain to crack a Fault Point.

We'll try to construct a Wrong Chain to kill the 7 in the Fault Point A.

If A = 7 then we have the following:

B = 6, C = 5, D = 7.

EEEE becomes a 2,3,4,5 Locked Set (because of D).

F = 7 (because of the 2,3,4,5 Locked Set EEEE).

G = 6, H = 5, I = 7.

That's a Conflict (two 7s in Column 5).

So the 7 in Cell A can't be true: we can kill that 7 — and then the entire Sudoku is cracked.

No, that one wasn't easy.

So some general advice is in order. Cracking a high-Degree Fault Point often means cracking the whole Sudoku, so it's tempting to try. And sometimes you can find a Chain. When the search goes on too long, however, it's time to try one of the other Tactics described on this page.

 

Fault Line = Tightly Linked Twin Chains

Up to this point, every Chain we've talked about has been an Attack Chain, which is a mechanism for carrying out an Attack. Now we want to talk about Twin Chains, which are a very different thing:  a Twin Chain is a Target Chain, which is a target to be attacked.

We will try to crack a Twin Chain because it's a Fault Line: if it's long, then it's a big line of weakness in the Grid, and cracking the Twin Chain might crack the whole Sudoku (or at least substantially clean up the Grid).

First, we need a bunch of terminology —

You recall that a House is a Row or a Column or a Block.

And (I say, redundantly) you know what Twins are:

Occasionally we need this term:

And (solely for the current discussion) we need this term:

And, temporarily, we need this term:

There's a problem with a 9-Twin group:  it could consist of a bunch of disjoint 9-Twin Chains. So finally, we come up with this definition of a Twin Chain:

(Similarly for a Twin Chain in 8 or 7 or 6 . . .)

You can see that the word Chain is used loosely here. A Twin Chain doesn't have to be a sequence — it can be forked here and there. (And it can have loops — that's not a problem.)

The meaning of move-connected is probably obvious, but here's a definition anyway:

OK, it took a long time to get here, but now we can look at a concrete case.

The notation used in the Grid below is defined in the page you've read on Twin Tagging.

Here's an example of a Fault Line consisting of a single Twin Chain:

Twin Chain in 6.

There are nine Cells in this Chain.

Every 6 in the Chain sees another 6 in the Chain which is its Twin (it can have up to 3 such Twins).

There are other 6s on the Grid which are not in this Chain. (Some of them are Triplets of one of the Chain 6s, but that's of no interest.)

If any one of the 6s in this Chain can be shown to be true or false, then the true/false status of all the 6s in the Chain will be determined.

That last remark is the point of this whole thing:  if we can prove one of the 6s in the Chain to be true or false, then we know the status of all the other 6s in the Chain. The reason for that is simple:  the truth/falsity status of the 6s in the Chain just alternates as you move through it.

That's why a Twin Chain is such a valuable target. If we can crack one Cell of the above Chain in 6, then in roughly half of the Chain Cells a 6 will be crowned, and in the other half a 6 will be eliminated.

How big does a Twin Chain have to be to represent a good chance of cracking the entire Sudoku? No magic rule, but as a rule of thumb, if a Twin Chain contains at least nine Cells, it's worth trying to construct an Attack Chain to crack the Twin Chain. (A Twin Chain that's longer than that is even better, but that's rare. We'll examine the solution to that problem soon.)

Here's the same Grid with an Attack Chain that cracks the Target Chain (a Gotcha Chain that cracks the Twin Chain):

Gotcha Chain to attack one of the 6s in a Twin Chain in 6:  same Grid as preceding.

(Here, the yellow Cells of the original Twin Chain are not important to the attack logic.)

The target of the Gotcha Chain is the 6 in one of the Twin Chain Cells (the purple Cell in Row 9).

If A = 6, it kills the purple Cell's 6.

If A = 5, then follow the Chain ABCDEFG and you'll see that G = 6, which again kills the purple Cell's 6.

So we can kill the 6 in the purple Cell. When we propagate the effect of that to the rest of the Twin Chain and then make all available moves, the entire Sudoku is cracked.

Now of course it will not surprise you that there's a catch to all this. We have no idea of which 6 in the Chain we should attack:  we don't know which 6s are false, and even for a false 6, we don't know whether we can succeed in finding an Attack Chain to kill it. You don't want to spend forever attacking one Cell — when you can't find an Attack Chain, then move on to a different Cell.

To determine the true/false status of one of the 6s in the Twin Chain, we don't necessarily have to kill a 6. Instead, if one of the Chain Cells contains a Pair, then we can try to kill the non-6 member of that Pair in order to crown the 6. That's what's done in the following example:

Gotcha Chain to attack a 6's partner in a Pair Cell of a Twin Chain in 6:  same Grid as preceding.

(Again, the yellow Cells of the original Twin Chain are not important to the attack logic.)

The target of the Gotcha Chain is the 5 in the purple Cell, which is a Pair Cell in the Twin Chain in 6.

If A = 5, it kills the purple Cell's 5.

If A = 3, then follow the Chain ABCDEFG and you'll see that G = 5, which again kills the purple Cell's 5.

So we can kill the 5 in the purple Cell and crown the 6. When we propagate the effect of that to the rest of the Twin Chain and then make all available moves, the Sudoku is cracked.

The above examples involved a Twin Chain of length nine. That does occur, but not frequently. Fortunately, there's a simple extension of this idea which gives us a chance to find a long Target Chain. We need Tightly Linked Twin Chains.

A Twin Chain in 9 and a Twin Chain in 7 are said to be tightly linked when —

The idea is really simple: if we successfully attack a Cell in the 7-Chain, then the true/false status of all the 7s in that Chain will be determined. That includes the {7 9} Cell, which means that now a 9 in the 9-Chain has become determined, so that the 9-Chain is also activated: the status of all its 9s is now known.

The 7-Chain and the 9-Chain, together, are still fully move-connected.

If you have several Twin Chains, it's not necessary for each Chain to be explicitly tightly linked to every other Chain. It's only necessary that the tight links provide a (possibly indirect) pathway from any Chain to any other Chain. (If you're a mathematician, you're muttering that I should be talking about the transitive closure of the relation tightly linked.)

(Sometimes it's convenient to use the singular, Tightly Linked Twin Chain, to refer to a group of Tightly Linked Twin Chains taken all together as one long Chain.)

All the Twins that define a Tightly Linked Twin Chain are called the Constituent Twins of the Chain.

Here's an example of a Fault Line consisting of six Tightly Linked Twin Chains:

Six Tightly Linked Twin Chains (in 2, 3, 4, 5, 6, 7).

The {2 7} Cell links the 7-Chain to the 2-Chain.

The {3 7} Cells link the 7-Chain to the 3-Chain.

The {5 7} Cell links the 7-Chain to the 5-Chain.

The {6 7} Cell links the 7-Chain to the 6-Chain.

The {4 6} Cell links the 6-Chain to the 4-Chain.

Directly or indirectly, all the Chains are tightly linked.

If any one of the Constituent Twins in this Chain can be shown to be true or false, then the true/false status of all the Chain's Constituent Twins is known.

Now the point of all that is that this big Chain contains sixteen Cells. If we can crack one of the Cells, there is a good chance that this will crack the whole Sudoku.

Here's the same Grid with an Attack Chain that cracks the Target Chain (a Gotcha Chain that cracks the Tightly Linked Twin Chain):

Gotcha Chain to attack one of the Constituent Twins in a set of Tightly Linked Twin Chains:  same Grid as preceding.

(Here, the yellow Cells of the original Twin Chain are not important to the attack logic.)

The target of the Gotcha Chain is the 3 in the purple Cell.

Either A = 3, or A = 1 and E = 3. In either case, the purple Cell's 3 is killed.

So we can kill the 3 in the purple Cell, and crown the 6. That activates the 6 Chain, which activates the 4 Chain; the 4 Chain activates the 7 Chain; and the 7 Chain activates all the remaining Chains. When all available moves are made, the entire Sudoku is cracked.

When you're stuck in a Sudoku, it happens fairly frequently that there exists a set of Tightly Linked Twin Chains occupying nine or more Cells, so in fact this is a Tactic which I use frequently.

So are you supposed to colour in all the Cells in the Tightly Linked Chain? No, I never do that on a paper Grid. Do you have to twin-tag the Chain? Well, in fact I do tag all the Twins in the Chain, as shown in the Grids above, since that makes the Chain visible.

When I'm looking for all the Tightly Linked Twin Chains in a Grid, I make a list in the margin indicating the Constituent Twins in each Tightly Linked Twin Chain and the total length of each Chain, like this —

Chains:

There are some shorter Chains too, but I ignore any Tightly Linked Twin Chain that occupies fewer than 5 Cells.  In fact, there is no need to make a complete list; but listing all the Chains of length 9 or greater is a good idea, because then you can think about them.

So what is there to think about?  If you have two fairly long Chains, then one of them might look like a better Target than the other.  I've tried cracking a lot of Tightly Linked Twin Chains, but I haven't found any airtight rules for declaring a Chain to be a really good Target.  Nevertheless, there are some things that are desirable:

What good do those qualities do? —

If you can only find a small 6-, 7-, or 8-Cell Tightly Linked Twin Chain, should you attack it? You can try. A successful attack probably won't crack the Sudoku, but it would help to clean up the Grid a little bit.

Even with the above criteria, what if you have a hard time deciding which of two separate Tightly Linked Twin Chains to attack?  Try the longer one first; if you can't find an Attack Chain, then try attacking the shorter Target Chain.

Now we should look at a borderline case. In the next example, the Tightly Linked Twin Chain is only of length 9, and the Grid itself is fairly uncooperative, with a high candie density in the empty Cells. So what we're going to see is that the Tightly Linked Twin Chain does turn out to be attackable, but it's only a so-so Fault Line, so cracking the Target Chain doesn't result in cracking the whole Sudoku. Specifically, we wind up having to re-analyze the resultant Grid to find a new Tightly Linked Twin Chain to attack. I'm going to have to display a total of four Grids to show all this.

Here's the starting Grid.  The biggest Fault Line is made up of three Tightly Linked Twin Chains, but it's only 9 Cells long:

Three Tightly Linked Twin Chains (in 1, 4, 8).

The {1 4} Cell links the 1-Chain to the 4-Chain.

The {4 8} Cell links the 4-Chain to the 8-Chain.

So directly or indirectly, all the Chains are tightly linked.

In fact (here) the {1 8} Cells also directly link the 1-Chain to the 8-Chain, but this additional direct linking is not required; the 1-Chain was already linked indirectly to the 8-Chain via the 4-Chain.

If any one of the Constituent Twins in this Chain can be shown to be true or false, then the true/false status of all the Chain's Twins will be determined.

Here's the same Grid with an Attack Chain that cracks the Target Chain. In this example I have used a Wrong Chain, which in fact is my preference for mounting an Attack on a Tightly Linked Twin Chain, because it works better to help me keep my mind on what I'm doing.

Wrong Chain to attack one of the Constituent Twins in a set of Tightly Linked Twin Chains:  same Grid as preceding.

(Here, the yellow Cells of the original Twin Chain are not important to the attack logic.)

The victim of the Wrong Chain is the 8-Twin in the purple Cell.

Starting with the assumption A = 8, we find the Chain ABCCDEFG that gives G = 8, which is a Conflict (two 8s in Row 1). So we know that A cannot equal 8.

So we can kill the 8 in the purple Cell. That activates the 8 Chain, which activates the 1 Chain and the 4 Chain. But when all available simple moves are made, we do not reach a Solution!

No Solution yet. Well, this is not the end of the world. The Fault Line in the Grid was not sufficiently weak to blow the whole Grid apart when we cracked the Line. But the Grid is cleaned up to some extent.

This is what the resultant Grid looks like after the Target Chain was cracked and all the resulting easy moves were made. We have to re-analyze this situation to see if we can find a new Worthy Target; and we do.

Grid resulting from the moves in the preceding Grid.

Now we see we've got a new set of four Tightly Linked Twin Chains (in 1, 2, 4, 6).  You can see the tight links in the four Pair Cells.

The Chain as a whole again has a length of only 9.  Oh dismery, are we back in the soup?

We'll try anyway.

Actually, things work out better this time:

Wrong Chain to attack one of the Twins in a set of Tightly Linked Twin Chains:  same Grid as preceding.

(The yellow Cells of the original Twin Chain are not important to the attack logic.)

The intended victim of the Wrong Chain is the 4 in the purple Cell.

Assuming P = 4, we finally manage to construct the Chain PQRSTUUV that gives V = 4, which is a Conflict (two 4s in Column 3). So we know that P cannot equal 4.

So we can kill the 4 in the purple Cell. That activates the 4 Chain, which activates the 1 and 2 Chains, which in turn activate the 6 Chain. And this time when all available moves are made, the whole Sudoku is finally cracked!

So attacking a Fault Line is a very reasonable thing to try.

What problem will you have in applying this Tactic?  Sometimes you just won't be able to find an Attack Chain. In that case, you might try to crack a different Fault Line (if there is one), or you might try a different Tactic altogether (if there are any left).

We can't win 'em all, but at least we can try to qualify for Valhalla.

 

The Heroes in a Unique Rectangle or a BUG+n

Exploiting a Unique Rectangle or a BUG+n often requires the use of Chains. These topics are discussed in detail on two separate pages:

These two subjects constitute a whole different world, so you'll see some similarities to the ideas on this page as well as some differences. The Chains used for a Unique Rectangle or a BUG+n are multiple Chains. But you will notice some consanguinity between Troublemaker Chains and Wrong Chains. Consensus Chains are conceptually different from the approach used on this page.

If you are quite familiar with the notions of a Unique Rectangle and a BUG+n, then you can read the material at the above links directly. If not, you should read the (long) background material in Deadly Patterns first.

And as a final remark, whether or not exploiting a UR will produce a cascade of Kills that cracks the entire Sudoku is a little iffy. In most cases we push for an exploitation that produces an immediate Crowning in some Cell, but there's a lot of variation on how many moves that Crowning will then generate.

 

Grid with Mostly Pair Cells

Sometimes you reach the point where most of the empty Cells in the Grid are Pair Cells, but there is no obvious move. In that case, there's a very good chance that successfully cracking any one of the Pair Cells will cause a cascade of moves that solves the Sudoku.

The following Grid has mostly Pair Cells (ignoring the BigNums). I picked one at random and tried to construct a Gotcha Chain to kill one of its candies. The try shown worked:

Mostly Pairs.  Gotcha Chain to kill a candie in one of the Pair Cells.

For the Chain ABC, either A = 9, or A = 5 and C = 9. In either case, the 9 in the purple Cell is killed.

Since there were only two possibilities (A = 9 or 5) and in both cases the purple Cell's 9 gets killed, it's clear that we can eliminate the 9 in the purple Cell.

And the cascade of moves generated by that Kill cracks the entire Sudoku.

The Gotcha Chain here turned out to be very short.

You will not be able to construct a Gotcha Chain on absolutely every Pair Cell, but if you have no luck with one candie, then work on another one (in the same Cell or in a different Cell). In general, there will be several Chains that you could find. For the same Grid as above, here's an example of a Gotcha Chain on a different Cell.

Mostly Pairs.  Gotcha Chain to kill a candie in one of the Pair Cells.

(Same Grid as in the preceding example.)

For the Chain PQRSTU, either P = 5, or P = 7 and U = 5. In either case, the 5 in the purple Cell is killed.

So we eliminate the purple Cell's 5.

Then the cascade of moves generated by that Kill cracks the entire Sudoku.

The Gotcha Chain here turned out to be fairly long, but it worked. Go with the first Chain you find, as long as its length and complexity don't prevent you from verifying it.

Now we'll switch to a different Grid. In this one, I'll choose to kill a candie in a Trio Cell rather than one in a Pair Cell. This doesn't seem too bright, until you notice that this will give rise to a new Locked Set which does in fact produce a cascade of Kills:

Mostly Pairs.  Gotcha Chain to kill a candie in a Trio Cell, which will give us a new Locked Pair.

For the Chain ABCDE, either A = 1, or A = 6 and E = 1. In either case, the 1 in the purple Cell is killed.

So we eliminate the purple Cell's 1.

This produces a new {6 7} {6 7} Locked Pair (in the purple Cell and the yellow Cell), which produces a Kill in the Pair Cell in R9C9.

And then the cascade of moves generated by that Kill cracks the entire Sudoku.

Another Grid.  In this one, I had to incorporate an Almost Locked Set in the Chain:

Mostly Pairs.  Gotcha Chain to kill a candie in one of the Pair Cells.

If A = 2, that kills the purple Cell's 2.

If A = 7, then we have the following:

B = 6.

C = 8.

DD becomes a 2,5 Locked Pair (because of C).

That Locked Pair kills the 2 in the purple Cell.

So we eliminate the purple Cell's 2.

Then the cascade of moves generated by that Kill cracks the entire Sudoku.

It's very common to want to make use of an Almost Locked Set embedded in a Chain. If you learn how to deal with these, it will greatly increase your chances of finding a Gotcha Chain that works.

So just for practice, we'll redo the same Grid, working on a different Cell. And we wind up needing an embedded Almost Locked Set again:

Mostly Pairs.  Gotcha Chain to kill a candie in one of the Pair Cells.

(Same Grid as above.)

The Chain is PQRSTT.

If P = 6, that kills the purple Cell's 6.

If P = 2, then we have the following:

Q = 7, R = 6, S = 9.

TT becomes a 2,6 Locked Pair (because of S).

That Locked Pair kills the 6 in the purple Cell.

So we eliminate the purple Cell's 6, and the cascade of moves generated by that Kill cracks the entire Sudoku.

That concludes the Tactics based on constructing a Directed Attack Chain. Now we want to look at situations where we might want to employ an Aimless Attack Chain.

 

Whittling Down

You can try to whittle down a Grid by finding and applying an Aimless Chain, possibly by carrying out a long sequence of such Chains. Usually, executing such a Chain does not lead directly to a Solution, and most of the time it doesn't even generate a cascade of moves, so it's not a terribly rewarding process.

There are three different reasons for which you might feel like applying an Aimless Chain:

As a first example, here's a Grid that doesn't seem to have any available moves except that there's a long Same-Pair Chain on the Grid (which of course is extremely obvious).

Same-Pair Chains were explained above on this page, along with the various other Aimless Chains.

This Same-Pair Chain has 5 Cells. You recall that a useful Same-Pair Chain has to have an even number of Cells, so we have to look at the two 4-Cell subchains of this Chain:

Whittling down. We see a Same-Pair Chain.

The Same-Pair Chain ABCDE has two 4-Cell Subchains.

The 4-Cell Subchain ABCD is a Gotcha Chain in both 3 and 8, so it kills the 3 and the 8 in the yellow Cell.

The 4-Cell Subchain BCDE is a Gotcha Chain in both 3 and 8, so it kills the 3 and the 8 in the orange Cell.

These Kills don't crack the Sudoku, but they help. See next Grid.

The relatively meager results of that Same-Pair Chain lead us to the following Grid. We're stuck again, except that we see that we've now got a BUG+1, so we're home free —

Whittling Down. Continuation of preceding Grid.

The empty Cells form a BUG+1:  so we can set the blue Cell equal to its Hero (8).

That, of course, cracks the Sudoku.

If you need to know what a BUG+1 is, you can read the page BUG+n.  If that's completely new to you, then you'll also have to slog through the page Deadly Patterns first.

Now for a different example. Here's a Grid with no obvious moves, so we trek through it looking for a 3-Pair-Cell Chain — and we find one:

Whittling down. We've located a 3-Pair-Cell Chain.

As is easily checked, either A = 5, or if A isn't 5 then C = 5.

A and C both see the yellow Cells. So the 5s in the yellow Cells are all killed.

This produces a significant number of Kills, but it doesn't crack the Sudoku. See next Grid.

This is the resulting Grid we get. There are several different ways that this Grid can now be cracked, but I will only mention one — there is in fact a new Sashimi:

Whittling down. Continuation of preceding Grid.

There's a new Sashimi in 5 in Rows 2 and 5.

The two yellow Cells are in the Kill Area of the Sashimi, so the 5s in those two Cells are killed.

And that's quite sufficient to crack this Sudoku.

If you need to read about Sashimis, they're covered in the page on 2-Fish.

Last example. Here's a Grid with no obvious moves, so we comb through it looking for a Little ALS Chain and, surprisingly, we find one:

Whittling down. We see a Little ALS Chain.

The Chain is ABB.

If A = 5, that kills the yellow Cell's 5.

Or if A = 8, then that converts BB into a 1,5 Locked Pair, and that again kills the 5 in the yellow Cell.

So we can definitively eliminate the yellow Cell's 5.

That doesn't give rise to any new moves at all, so things are looking pretty grim. But see next Grid.

The result of that little gambit seems really useless. I don't see any new Locked Sets, Claims, or Fish.  But . . . then I notice that that single Kill from the Little ALS Chain has produced a new 3-Pair-Cell Chain:

Whittling down. Continuation of preceding Grid.

There's a new 3-Pair-Cell Chain PQR.

It's a Gotcha Chain in 6 which kills the 6 in the yellow Cell.

And because of that Kill, there's a new 1,5,8 Locked Trio in Row 3, and a new 1,5,9 Locked Trio in Column 5.

Both of these Locked Trios produce a significant Kill, and, amazingly, that's enough to crack this Sudoku.

This notion of whittling down a Grid can be carried farther. You can find Sudoku solvers on the web that routinely crack hard Sudokus by looking for a succession of aimless Gotcha Chains. (An aimless Gotcha Chain in 9 is an Attack Chain with two heads such that if one head isn't equal to 9, then the other head is.  The Target Area consists of any Cell(s) that both heads see. If the Target Area happens to contain any 9-candies, then those 9s are killed.)  I don't deal with Aimless Chains of that sort on this site because I prefer the approach of determining and then attacking a Worthy Target.

OK.  End of Chain examples.

 

Digression on Logic

You don't have to read this section. These remarks would be of interest only to people who are really uncomfortable with the fact that, when they're trying to construct a Chain, sometimes it seems like anything at all can be proved (under the starting assumption).

What happens if we start with a false assumption but then proceed logically from there?

Try this as a starting assumption:

(a) 2 = 3

Now add 4 to both sides:

(b) 6 = 7

That's our first result:  6 = 7.

Then from the same starting assumption:

(a) 2 = 3

Use the fact that equations are symmetric:

(r) 3 = 2

Add (a) and (r):

(s) 5 = 5

Add 1 to both sides:

(t) 6 = 6

That's our second result. In summary, we've shown two things:

Isn't it wonderful what you can do with a false assumption? You can wind up proving almost anything, including some results that are contrary to each other.

Similarly, in a Sudoku Chain, we initiate the Chain by assuming that some candie in the Chain's first Cell is true. (We usually don't even know in advance whether that assumption is true or false.) If in fact that assumption is wrong, then, depending on how we construct the Chain, we can easily find ourselves demonstrating contrary things from the same assumption. So we do something very odd: we retain the Chain that shows what we want. How can this possibly be useful?

For a Wrong Chain, this doesn't seem terribly problematic. After all, we're trying to show that the assumption itself is faulty, so if we can construct any Chain that produces a Conflict, we've achieved our goal, since that means that the assumption must be wrong.

For a Gotcha Chain, it may not all seem as obviously OK — but it is. We're trying to prove something (X), and the argument proceeds from the first Cell of a Chain. What we've done is this:

What we say is this: there are only two choices for the Cell {ab} and both choices imply the result X, so X must be true. But one of those two choices must be false, which means that one of the two arguments is garbage (and we don't even know which is which). However, one of those choices was correct, so for that one, the argument and conclusion are valid. Since we have laboriously found arguments to give the same conclusion (X), we know, since one of the arguments is actually valid, that X is actually true.

What's the point? Well, you were trying to construct a Chain to prove that some candie c in some Cell gets killed. In the process, you probably found some Chains that show that c doesn't get killed. You might not succeed at all, of course. But if you finally do, then you have the second half of the argument above, and your conclusion (X = "c is killed") is safe, because one of the two arguments stems from a correct assumption and is valid.

I guess I hammered this into the ground, didn't I?  People tell me I have a tendency to do that . . .

 

 

This page was last updated on 2011 January 7.

The home page for this site is   alcor.concordia.ca/~stk/sudoku/

 

Scroll