pjb wrote:Almost SK (+1) Loops

This section is added out of interest, as trial and error is employed.

These are every bit as common as SK loops. They have 17 links rather than the 16 of normal SK loops. They differ by having a linking triple rather than a linking pair in one of the boxes or rows/columns. The bidirectional logic is still there, but an absurdity is introduced by suggesting 3 numbers to be true in the 2 linking cells. The result of this is that in the final solution one is trying to fit 17 numbers into the 16 cells of the SK pattern. The one that is squeezed out leads to just one of the eliminations being false, ie the candidate elimination must be true. One can test this simply by in turn making each candidate elimination true and the rest false, and then testing to see if it creates a contradiction. In all of the vast number of cases I've tested, this theory holds up. Thus this number can be assigned to the cell, and the remaining candidate eliminations can be carried out. I would be delighted if someone could discover a theoretic framework to establish this

approach to be valid.

...

As I discuss in my post, the proposition for "Almost (+1) loops" that one of the predicted eliminations based on the loop must be actually not false but true, stands up to every one of a huge number tested. Similarly for "Almost (+2) loops". Maybe there is a way to link this observation with approaches such as exocets and truth/link sets.

I don't know how it links to Exocets, but I'm eager to learn, because this approach doesn't seem like a manually applicable or a very interesting way to solve. It does seem quite valid in terms of set logic, though.

The normal SK-Loops are Rank 0, which means there's an equal number of base and cover sets (links). It guarantees that every link will be occupied by a base candidate, thus every non-base candidate in the links can be eliminated. Otherwise, if any of them were true, there wouldn't be enough candidates to fill the bases (thus no solution).

However, your almost-SK-Loops are Rank N (N > 0), meaning they have N more cover links than base sets. It means that there won't be enough base truths to fill all the links. In normal Rank N logic we get an elimination when N+1 links gang up on a candidate, because at least one of them is guaranteed to hold a base truth, or if some triplet magic occurs, which lowers the rank in some branch locally. That doesn't work here because there aren't any overlapping links or triplets.

As far as I understand, your approach seems to depend on the fact that, since every link needs a truth too, N of them must be external to the bases in a Rank N pattern. For example, a Rank 1 loop (+1) will have a single external candidate true in one of the links (but you don't know which link or which candidate). That single external truth, once discovered, is enough to turn the rest of the pattern into Rank 0 mode where all the other links are occupied by base candidates. So, in that light it is indeed valid that once you find that single external truth for one of the links, then the other eliminations become valid (or if you manage to eliminate all but one candidate from the list then you can place the last one). For example:

.......39.....1..5..3.5.8....8.9...6.7...2...1..4.......9.8..5..2....6..4..7.....; Golden Nugget

1 Almost (+1) SK loop detected (red cells): (35=24)r4c12 - (24=56)r56c3 - (56=17)r89c3 - (17=36)r7c12 - (36=124)r7c46 - (124=36)r89c5 - (36=17)r56c5 - (17=35)r4c46 - loop

No contradiction when 5 at 4,7 is true and others are all false

Eliminations (green cells): r4c7 <> 3, r7c7 <> 3, r7c9 <> 3, r1c3 <> 5, r1c3 <> 6, r2c3 <> 6, r1c5 <> 6, r2c5 <> 3, r2c5 <> 6, r5c4 <> 1, r6c6 <> 7, r8c1 <> 7, r9c2 <> 1, r8c4 <> 1, r8c6 <> 4

In truths and links I see this:

Alien 16-Fish (Rank 1): {47N1246 5689N35} \ {35r4 36r7 56c3 36c5 24b4 17b5 17b7 124b8}

That's 16 truths and 17 links. However, by placing 5r4c7 you remove the 5r4 link turning it into 16/16, i.e. Rank 0:

Alien 16-Fish (Rank 0): {47N1246 5689N35} \ {3r4 36r7 56c3 36c5 24b4 17b5 17b7 124b8} => 15 elims

In other words, I see your approach as perfectly valid logically. Do I like it? Well... to begin with, it doesn't sound like a lot of fun for a manual solver. More than that, I'm not sure how much sense it makes either.

If your Rank 1 loop has say 16 (-1) potential eliminations like here, you have to test 16 candidates for contradictions to get to place one (discounting any ripple effects). Basically it's like a SIS of 16 candidates, in which exactly one candidate is true. How do you know which one? By testing them all, because you obviously can't stop and place a candidate if you don't find a contradiction for it -- that'd be a rookie mistake -- unless you find the full solution but then that's that (and not very fun). If you're lucky enough to get contradictions for the first 15 then you technically don't need to test the last one because it must be true.

If you're employing T&E anyway, why not simply take a smaller SIS with much less to test and a guaranteed (and probably more strategic) placement sooner? With this method you get 15 eliminations and 1 randomly located placement (in this example) -- by fully testing 16 candidates, which doesn't seem like a great payday for an already tedious and ugly method like T&E.

Thus this number can be assigned to the cell, and the remaining candidate eliminations can be carried out.

Well, if you already tested them for contradictions, you could (should) have eliminated them already (after finding each contradiction). Thus revealing the pattern this way gains you nothing -- except the one placement (and the 15 eliminations but you could probably find more useful candidates to eliminate via T&E, so why these?). The Rank 0 pattern is dead when you finally have it because all its eliminations have been found on the way there. Right?

Or perhaps I've totally misunderstood something and you can explain how it actually helps.

PS. I could see the most value in this method with a pattern of very few potential eliminations, because then that list could actually be used as a derived SIS to force other eliminations without T&E -- or at least find the contained placement(s) more easily with T&E. The more potential eliminations this has, the worse it is, unless there's some other way to turn it into Rank 0 mode.