ReCiviliza wrote:All three examples used were intended to indicate 4 linked cells in say a hook shape

Ok, thanks for the clarification. My interpretation was wrong, then. No worries, though. Let's take another look.

In my mind the first two could be in a common row, the second and third in a common block and the third and fourth in a common column.

Such a pattern would be an

L3-Wing. The 'L' means that it has only bi

Local strong links, '3' means it uses three different digits (the other possibilities are L1 and L2), and 'Wing' means it has exactly three strong links. The last part is true about all 'one-letter-wings' (Y,H,W,S,M,L) but not (UVW)XY(Z)-Wings which are ALS-Z patterns (two strongly-linked ALSs). As a chain:

L3-Wing: [a = (a-b) = (b-c) = c] => -a (in last cell), -c (in first cell) if the end-points see each other

Example 1:

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

| 123456789 123456789 123456789 | 123456789 13456789 123456789 | 123456789 123456789 123456789 |

| a1'2456789-3 23456789 23456789 | 23456789 b1"2'3456789 23456789 | 23456789 23456789 23456789 |

| 123456789 123456789 123456789 | 123456789 13456789 123456789 | 123456789 123456789 123456789 |

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

| 123456789 123456789 123456789 | 123456789 13456789 123456789 | 123456789 123456789 123456789 |

| d3"2456789-1 12456789 12456789 | 12456789 c2"3'1456789 12456789 | 12456789 12456789 12456789 |

| 123456789 123456789 123456789 | 123456789 13456789 123456789 | 123456789 123456789 123456789 |

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

| 123456789 123456789 123456789 | 123456789 13456789 123456789 | 123456789 123456789 123456789 |

| 123456789 123456789 123456789 | 123456789 13456789 123456789 | 123456789 123456789 123456789 |

| 123456789 123456789 123456789 | 123456789 13456789 123456789 | 123456789 123456789 123456789 |

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

L3-Wing: [(1)r2c1 = (1-2)r2c5 = (2-3)r5c5 = (3)r5c1] => -1 r5c1, -3 r2c1

Note that the end-points have different digits, so they can only eliminate from each other -- not externally. To have the same digit at both ends (without the pattern degenerating into a Skyscraper) we need a bit longer chain:

[a = (a-b) = (b-c) = (c-a) = a] => -a (sees both start and end cell)

Example 2:

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

| 123456789 123456789 23456789-1 | 13456789 13456789 1456789 | 123456789 123456789 123456789 |

| a1'23456789 23456789 23456789 | 3456789 b1"2'3456789 456789 | 23456789 23456789 23456789 |

| 123456789 123456789 23456789-1 | 13456789 13456789 c2"3'1456789 | 123456789 123456789 123456789 |

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

| 23456789-1 123456789 123456789 | 123456789 123456789 12456789 | 123456789 123456789 123456789 |

| 23456789-1 123456789 123456789 | 123456789 123456789 12456789 | 123456789 123456789 123456789 |

| 23456789 23456789 e1"23456789 | 23456789 23456789 d3"1'2456789 | 23456789 23456789 23456789 |

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

| 123456789 123456789 123456789 | 123456789 123456789 12456789 | 123456789 123456789 123456789 |

| 123456789 123456789 123456789 | 123456789 123456789 12456789 | 123456789 123456789 123456789 |

| 123456789 123456789 123456789 | 123456789 123456789 12456789 | 123456789 123456789 123456789 |

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

[(1)r2c1 = (1-2)r2c5 = (2-3)r3c6 = (3-1)r6c6 = (1)r6c3] => -1 r13c3,r45c1

The official name for that pattern is:

_xXx_OvErLy_ObNoXiOuS_sUdOkU_tEcHnIqUe_NaMe_xXx123456.

I'm not kidding Despite

999_Spring's valiant efforts, the boring truth is there are no standard names for most chains longer than three strong links. Worrying about pattern names should be secondary to having a good chain notation anyway, because almost all named patterns can be written as chains (some fishes and other complex patterns excluded). Personally I learned generic chaining first, and only after a considerable while I learned to name some of the found chains too. Names are fun to know, and sometimes ease up communication, but for actual solving they're just as optional as memorizing specific patterns.

Hence the strong links between all of the cells in the third example.

Like I said, when you write a chain (or even think about it), the links must always alternate, no exception. Otherwise the logic doesn't work at all if the AIC is translated into Boolean logic. What might be confusing for chaining novices is that the native strong links (bivalue, bilocal) are in fact

hybrid links. It means that they're

both strong and weak, so they can be used in either role. When they're used as weak links, it makes no difference that they're also strong, and they're certainly not written as strong links in the chain then. The same is obviously true the other way when they're used as strong links. An AIC only uses one or the other inference type at a time, and the one actually used is written in the chain.

A hybrid link has the property that

exactly one of the two linked items must be true. In terms of Boolean logic they represent XOR gates:

(a XOR b) <=> ((a OR b) AND (a NAND b))

The OR part means that they're strong links (at least one true), and the NAND part means they're also weak links (at most one true). Thus you can use a native strong link for either role in an AIC, but never for both simultaneously. Note also that not all strong links are hybrids, which means that some of them you can only use as strong links but not as weak links.

I am aware that sooner or later I am going to have to implement a full AIC but now I am trying to find a complement to the XY Chain (in which the values are strongly linked within each cell and weakly linked between the cells) whereby the values are weakly linked within each cell but strongly linked between the cells.

Did my (theoretical) examples above help at all? If not, make a Google search on "L3-Wing" on this site (and possibly elsewhere). The search functionality on this site doesn't work when the keyword has dashes.

I guess using SpAce's nomenclature (combined with my interpretation that brackets denominate the contents of a cell)

It's almost a standard interpretation. Brackets are indeed used to surround candidates in a cell, but also digits in a group of cells (as in a locked set). When you write symbolic chains with nodes like (amb) it's not possible to know whether you mean a single cell with three candidates or a locked set of three digits in three cells. Such ambiguities should be clarified in text or otherwise. In a real chain that would be clear, of course, because it shows the cells too. In fact, the least ambiguous way to write a single cell with three candidates is (a|m|b) because they're really ORed -- only one of them can be true, not all three.

What I want a name for is:

[(a-b)=(b-c)=(c-d)=(d-a)] => oh! I see the problem now, while b to d is locked in there is no guarantee that either of the end cells will actually have the value a instead of my arbitrary masking value(s).

Well, even if either or both (b,d) do have an 'a' in their cells, they can't eliminate it. Remember that both ends must see the same elimination. The only way b and d could see the same a is if all three are in the same cell. In fact, if b and d were in the same cell (but not the same candidate), it would be a continuous loop with a lot more eliminations. That possibility requires a bit longer chain:

[b = (b-c) = (c-d) = (d-e) = e - loop] => -all other candidates in the four cells

Example 3:

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

| 12346789 123456789 123456789 | 123456789 12456789 123456789 | 123456789 123456789 123456789 |

| a25-1346789 13456789 13456789 | 13456789 b23-1456789 13456789 | 13456789 13456789 13456789 |

| 12346789 123456789 123456789 | 123456789 12456789 123456789 | 123456789 123456789 123456789 |

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

| 12346789 123456789 123456789 | 123456789 12456789 123456789 | 123456789 123456789 123456789 |

| d45-1236789 12356789 12356789 | 12356789 c34-1256789 12356789 | 12356789 12356789 12356789 |

| 12346789 123456789 123456789 | 123456789 12456789 123456789 | 123456789 123456789 123456789 |

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

| 12346789 123456789 123456789 | 123456789 12456789 123456789 | 123456789 123456789 123456789 |

| 12346789 123456789 123456789 | 123456789 12456789 123456789 | 123456789 123456789 123456789 |

| 12346789 123456789 123456789 | 123456789 12456789 123456789 | 123456789 123456789 123456789 |

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

[(2)r2c1 = (2-3)r2c5 = (3-4)r5c5 = (4-5)r5c1 = (5)r2c1 - loop] => -1346789 r2c1, -1456789 r2c5, -1256789 r5c5, -1236789 r5c1

Pretty cool, huh? Based on

this, that might be called

Strong Ring.

[(a-b)=(b-c)=(c-d)=(d-a)]

The a's at the ends:are only weakly linked to each other.

Correct. Thus you know that at most one of them can be true. While it doesn't give any direct eliminations, it's a bit of new knowledge at least. It's a good skill to learn to read such derived inferences from AICs, so good job for seeing that!

Similarly (and more commonly) we have strong links at both ends of the chain, which means we know the end points are strongly linked to each other (thus at least one must be true). Those two are the only end point configurations I accept: either both strong (idiomatic AIC, preferable) or both weak (the mostly obsolete DNL style). I can't stand it when people write chains with mixed links at the ends, because the Boolean relationship between the end points is then neither OR nor NAND but an implication (which shouldn't normally be mixed with AICs at all).