The New Sudoku Players' Forum

[StrmCkr]

mutifish being a hint i dropped as the best way to describe what i was seeing when early exploring "fata morgana" when i noticed a groups of digits landing in a fish like state allowing deductions, i then pm'd several uses about to see if they could match my findings and post a good write up on or develop the theory of its my writing skills are deplorable. Alla's set solver was key in proving its validly.

champagne,ttt, Paul, Allan a few others most of it all via pm

sharks: was Davids early form of mutifish which then hybridize and eventual msls renamed after an issue occurred in the sharks thread between the author and ronk whom polluted the thread:

Sharks attempted to just use the hidden-sets the same as n fish, until half way through David realized that the hidden and away set intersect between base and cover. Thus always have the same number of digits. That's the balancing act and truth balance to qip david

when looking at 4 sectors where the 9 digits (home is 4 digits {naked set}, away is 5 digits {hidden set}) or vice versa. all 9 digits are exactly counted in all sectors
{as hidden set, givens, naked set}

Which ever set has more then the max cell count is out of balance. This idea halted sharks plus the argument killed it completely as the thread diverted from its original intent and became muddled and hard to follow, David moved the concept on-wards with the new name msls

sk loops loops are the easiest to show as they are 4 sectors with a total count of or (16+16) or (24+8) nets zero uncovered cells.
((4*9)-4 ) = 32 cells holding 9 digits.

sk loops in the usual general naked from are a size 7 naked set in 4 sectors with also hold a size 2 hidden set with all digits of both sets accounted for.
in other words 16 cells left for the naked set to fill. and 16 cells holding the hidden set.

the hidden set version is A size 4 hidden set with 4 sectors holding a size 5 naked set meaning that 24 cells are holding a size 4 hidden set. and 8 cells hold the naked set

the givens in both cases is where the "digestion" part arrives they are counted as part of the naked set
however when cell counting they are counted as "empty"

both end up rank zero.

see the following grid to see what i mean {at least i hope} for the balancing act described above.

they exists at the same time an example: of both on the same grid with eliminations
strmckr's 11.4

Code: Select all

.----------------------.---------------------.----------------------.
| 5       137    1467  | 23468  234678  378  | 12     468    9      |
| 346     2      469   | 1      34689   3589 | 456    7      468    |
| 1467    179    8     | 24569  24679   579  | 3      456    12     |
:----------------------+---------------------+----------------------:
| 13678   4      15679 | 389    1389    2    | 5679   35689  3678   |
| 123678  13789  12679 | 3489   5       1389 | 24679  34689  234678 |
| 238     3589   259   | 7      3489    6    | 2459   1      2348   |
:----------------------+---------------------+----------------------:
| 24      157    3     | 2569   12679   1579 | 8      469    1467   |
| 178     6      157   | 3589   13789   4    | 179    2      137    |
| 9       178    24    | 2368   123678  1378 | 1467   346    5      |
'----------------------'---------------------'----------------------'

standard typical Sk-loop - {size 7 Naked set & size 2 hidden set } {eliminates external}

Code: Select all

+-----------------------+---------------------+-----------------------+
| 5       (137)   1467  | 23468  234678  378  | 12     (468)   9      |
| (346)   2       (469) | 1      389-46  3589 | (456)  7       (468)  |
| 1467    (179)   8     | 24569  24679   579  | 3      (456)   12     |
+-----------------------+---------------------+-----------------------+
| 13678   4       15679 | 389    1389    2    | 5679   3589-6  3678   |
| 123678  389-17  12679 | 3489   5       1389 | 24679  389-46  234678 |
| 238     3589    259   | 7      3489    6    | 2459   1       2348   |
+-----------------------+---------------------+-----------------------+
| 24      (157)   3     | 2569   12679   1579 | 8      (469)   1467   |
| (178)   6       (157) | 3589   389-17  4    | (179)  2       (137)  |
| 9       (178)   24    | 2368   123678  1378 | 1467   (346)   5      |
+-----------------------+---------------------+-----------------------+

the hidden sk version: {size 4 hidden set & size 5 naked set } {eliminates internal}

Code: Select all

+-------------------------+--------------------------+-------------------------+
| 5       17(3)     1467  | 23468   234678    378    | 12     46(8)     9      |
| 46(3)   2         46(9) | 1       -46(389)  (3589) | 46(5)  7         46(8)  |
| 1467    17(9)     8     | 24569   24679     579    | 3      46(5)     12     |
+-------------------------+--------------------------+-------------------------+
| 13678   4         15679 | 389     1389      2      | 5679   -6(3589)  3678   |
| 123678  -17(389)  12679 | 3489    5         1389   | 24679  -46(389)  234678 |
| 238     (3589)    259   | 7       3489      6      | 2459   1         2348   |
+-------------------------+--------------------------+-------------------------+
| 24      17(5)     3     | 2569    12679     1579   | 8      46(9)     1467   |
| 17(8)   6         17(5) | (3589)  -17(389)  4      | 17(9)  2         17(3)  |
| 9       17(8)     24    | 2368    123678    1378   | 1467   46(3)     5      |
+-------------------------+--------------------------+-------------------------+

Limitations for msls as a designed of row/col design is boxes since it involves muti re counts on digits that in overlapping sectors borkes the counts.

To fix it should move into a system similar to obimath methods and they function pretty good. (haven't tested in code yet, but hand copies show they can)

[champagne]

That said, I actually found a relatively decent definition of Multi-Fish, so I have to (at least partly) absolve champagne

Hi SpAce,
Just considering my poor English language level, I take this as a compliment

I just fly over this thread for the time being. I am working on another topic.

Some comments however if it can help.

The MSLS's is one family of rank 0 logic not yet well identified when I open the "Exotic patterns" thread.

But more on Allan Barker very efficient Xsudo program. I tried years ago to understand with Allan's help how the program worked and I had the opportunity to meet him in Bangkok. As Allan left interest in this field, we have small chances to see him contributing to the discussion.

The first specificity of Allan's program is the graphic representation of the solution. If I caught it correctly, this is something that he developed in another field and translated in the sudoku field.

The program logic is based on the 81 cells + 9x 27 digits basic sets. The core process consider a given group of sets and explore all valid solutions, finding eliminations and assignments forced by this group of sets (pure brute force solver).

As such, Xsudo appears as a kind of universal tool to check a given group of sets.

The Sets Linksets split was a logic way to explain the results. This had already been explored by others (matrix).

Allan developed also a "group of sets" builder. The "fata morgana" solution was produced in this way. Although Allan was quite open to share his process, I never found in this process a general way to produce good solutions.

This is how I open 2 tracks, the rank 0 logic and the Exocet logic, 2 sub fields easier to handle.

The AUR threat was introduced later (very efficiently) by Allan when "abi" described this loop clearing many cases in the "Exocet patterns".

Again, in Xsudo, this is done in a very general way and can be used in any group of sets.

Allan produced some comments on the sets link sets groups. The analysis is clear and simple as long as we have a rank 0 logic. With a limited number of triple points (sets of link), Allan could still give some clues on the part of the field having a rank 0 logic, but when he tried to explain the results of the "Exotic pattern" in "fata morgana" where we had 3 triple points in sets, the stuff available did not give the answer.

Personally, when I work in this field, I always check the result using Xsudo.

[Ajò Dimonios]

Hi Phil

Phil wrote:

Your original question comes down to what you regard as an SK loop and what you regard as an MSLS. For example, I have found that all "vanilla" SK loops (all links double) have a corresponding MSLS. However, variant SK loops, a large number of which are on my website, mostly don't. In contrast, a great many of the MSLS's that I have documented do not have an SK loop.

I agree that MSLS's are not well defined, and I can't claim my coding is anything special, so when I say I don't find them in puzzles with variant SK loops, perhaps someone else will.

Ihave tried several "Variant SK loops" present in your solver and I have always found a msls that the solver fails to identify, probably the program does not consider the msls obtained from the intersection of two lines, two columns and four blocks. I believe that a msls is the subset obtained from the common cells of n columns with m rows or even the subset obtained from the cells common to blocks, rows and columns. In this case, it can always be shown with rank = 0 that candidates outside the subset that see internal candidates in the same column or block row can be deleted. I give you an example that I took randomly from your site.
..5...7...9...1.3.6.8.....2.....6.1.....8.....4.3.7...7.....8.6.5.9...2...2...5..

Code: Select all

+-------------------+--------------------+--------------------+
| 1234  123   5     | 2468   23469 23489 | 7     4689  1489   |
| 24    9     47    | 245678 24567 1     | 46    3     458    |
| 6     137   8     | 457    34579 3459  | 149   459   2      |
+-------------------+--------------------+--------------------+
| 23589 2378  379   | 245    2459  6     | 2349  1     345789 |
| 12359 12367 13679 | 1245   8     2459  | 23469 45679 34579  |
| 12589 4     169   | 3      1259  7     | 269   5689  589    |
+-------------------+--------------------+--------------------+
| 7     13    1349  | 1245   12345 2345  | 8     49    6      |
| 1348  5     1346  | 9      13467 348   | 134   2     1347   |
| 13489 1368  2     | 14678  13467 348   | 5     479   13479  |
+-------------------+--------------------+--------------------+


2 Variant SK loop detected (red cells): (4=27)r2c13 - (27=13)r13c2 - (13=68)r79c2 - (68=134)r8c13 - (134=7)r8c79 - (7=49)r79c8 - (49=568)r13c8 - (568=4)r2c79 - loop
17 Eliminations (green cells): r2c4 <> 4, r2c5 <> 4, r8c5 <> 1, r8c5 <> 3, r8c5 <> 4, r8c6 <> 3, r8c6 <> 4, r4c2 <> 3, r5c2 <> 1, r5c2 <> 3, r5c8 <> 4, r5c8 <> 9, r6c8 <> 9, r1c1 <> 2, r1c9 <> 8, r9c1 <> 8, r9c9 <> 7

3 Variant SK loop detected (red cells): (134=68)r8c13 - (68=13)r79c2 - (13=27)r13c2 - (27=4)r2c13 - (4=568)r2c79 - (568=49)r13c8 - (49=7)r79c8 - (7=134)r8c79 - loop
17 Eliminations (green cells): r8c5 <> 1, r8c5 <> 3, r8c5 <> 4, r8c6 <> 3, r8c6 <> 4, r2c4 <> 4, r2c5 <> 4, r4c2 <> 3, r5c2 <> 1, r5c2 <> 3, r5c8 <> 4, r5c8 <> 9, r6c8 <> 9, r9c1 <> 8, r9c9 <> 7, r1c1 <> 2, r1c9 <> 8








Msls

Base 25678
16 cell Truths: c28 r28 b1 b3 b7 b9
16 links: 27b1, 685b3, 68b7, 7b9, 13c2,49c8, 4r2, 134r8
17 Eliminations : r8c5 <> 1, r8c5 <> 3, r8c5 <> 4, r8c6 <> 3, r8c6 <> 4, r2c4 <> 4, r2c5 <> 4, r4c2 <> 3, r5c2 <> 1, r5c2 <> 3, r5c8 <> 4, r5c8 <> 9, r6c8 <> 9, r9c1 <> 8, r9c9 <> 7, r1c1 <> 2, r1c9 <> 8

If it is true that each sk-loop can be expressed as a msls then the property you found in almost sk-loops is demonstrated.

Ciao a Tutti.
Paolo

[creint]

Thank you for your information champagne, that was probably the last piece of information I needed to implement Xsudo in my variant solver.
Xsudo is not capable of discovering UR treats, would be nice if my solver could.
Now I only need to know an algorithm for discovering those.
After that an algorithm to canonicalize a grid would be nice.

[SpAce]

Msls

Base 25678
16 cell Truths: c28 r28 b1 b3 b7 b9
16 links: 27b1, 685b3, 68b7, 7b9, 13c2,49c8, 4r2, 134r8
17 Eliminations : r8c5 <> 1, r8c5 <> 3, r8c5 <> 4, r8c6 <> 3, r8c6 <> 4, r2c4 <> 4, r2c5 <> 4, r4c2 <> 3, r5c2 <> 1, r5c2 <> 3, r5c8 <> 4, r5c8 <> 9, r6c8 <> 9, r9c1 <> 8, r9c9 <> 7, r1c1 <> 2, r1c9 <> 8

I get the same result:

16x16 Rank 0: {1379N28 28N1379 \ 4r2 134r8 13c2 49c8 27b1 568b3 68b7 7b9} => 17 elims.

To me that looks like an MSNS, and I'm pretty sure the same is true for all the other "variant SK-Loops". I think such patterns are most definitely MSLS. On the other hand, calling them SK-Loops is a stretch, as far as I'm concerned.

Base 25678

What does that mean? I've been wondering about the same thing in Phil's solver.

Added. I guess that must mean the "Home" set, in both cases. Is there any particular reason why it's called base? That's a really bad idea in a context of base and cover sets. Very confusing. That's exactly why David chose his peculiar names for the two complementary digit sets:

The digits are partitioned into two sets – a 'Home' set typically of 4 digits and the complementary 'Away' set of 5 digits (these names have been selected to avoid any confusion with base and cover sets.)

In this case I really agree with David.

16 cell Truths: c28 r28 b1 b3 b7 b9

Is that the standard MSLS style of listing cell truths? Could it be any more confusing? This is exactly what I meant when I complained about David's "hybrid style" (though I'm not sure if this is really it or your own).

Why not simply use the XSudo notation {1379N28 28N1379}, since we're in any case talking about truths and links and any attempt to hide that fact just complicates things?

Added. If the MSLS method must be emphasized, I think it should be all the way:

Home: (1349)r28,c28
Away: (25678)b1379

...and then list the truths and links in XSudo style anyway, because nothing else really makes sense.

[pjb]

Thanks Paolo

Your post reminds me that I made a decision in the past not to bother coding SK loops as MSLS's in the rrccbbbb configuration, since they conveyed exactly the same results as the SK loop. However, the standard SK loops all have MSLS's of the rrrrcccc or similar types, which often yield different results to the SK loop, although with follow-on moves the end result is usually the same.

Cheers,
Phil

[Ajò Dimonios]

Hi Space

Yes, surely it is more useful to use an identical nomenclature to identify the truth cells, however I do not believe it is up to me to standardize the nomenclature. Certainly when I wrote "16 cell Truths: c28 r28 b1 b3 b7 b9" I meant the 16 cells that are common to the rows and blocks columns I listed. In practice I wanted to highlight how the cells are obtained where the sixteen digits in the links must be inserted in the solution. The term "1379N28 28N1379" is precise, it indicates exactly the result of this operation, in fact it is linked to the logic of XSudo (base sets, cover sets). Surely "Home: (1349) r28, c28. Away: (25678) b1379) ”is more precise because it indicates exactly the digits sets and the areas where to insert the missing ones present in the links.

Ciao a Tutti
Paolo

[champagne]

Hi Space

Yes, surely it is more useful to use an identical nomenclature to identify the truth cells, however I do not believe it is up to me to standardize the nomenclature. Certainly when I wrote "16 cell Truths: c28 r28 b1 b3 b7 b9" I meant the 16 cells that are common to the rows and blocks columns I listed. In practice I wanted to highlight how the cells are obtained where the sixteen digits in the links must be inserted in the solution. The term "1379N28 28N1379" is precise, it indicates exactly the result of this operation, in fact it is linked to the logic of XSudo (base sets, cover sets). Surely "Home: (1349) r28, c28. Away: (25678) b1379) ”is more precise because it indicates exactly the digits sets and the areas where to insert the missing ones present in the links.

Ciao a Tutti
Paolo

Speaking of a rank 0 logic, the Xsudo notation has the huge advantage to be clear and well known.
Any alternative way to describe the truhs/links should help the reader to better understand why eliminations/assignments are valid.
Personally, I don't like (I have difficulties with..) the 28N1379 notation, I use instead rxcy for the cells truths (eg r12c4 for the cells r1c4 and r2c4) and drx;dcx;dbx for the digits sets (eg 12c4 for the sets 1c4 and 2c4) but I stay strictly in truths/links mode

[SpAce]

Hi Paolo,

Certainly when I wrote "16 cell Truths: c28 r28 b1 b3 b7 b9" I meant the 16 cells that are common to the rows and blocks columns I listed.

I understood your intention, but it wouldn't have been at all obvious without the introductory "16 cell Truths". That hinted to the correct interpretation, but without it they would have rather looked like cover sets to me. With pure set logic notation no such introduction is necessary (though it may be helpful), because all the relevant information is in the notation itself (including the capitalization of truths). All that is really needed to understand and rebuild the pattern is this:

{1379N28 28N1379 \ 4r2 134r8 13c2 49c8 27b1 568b3 68b7 7b9}

There's no ambiguity of which sets are truths (bases) and which are links (covers) even if they're not specifically mentioned. The Rank 0 nature can be deduced by counting both sides and noticing that no triplets exist. The MSNS nature is obvious because there are only cell truths (which the N-notation makes very clear). So, it's all there even though it's not necessarily nice to read without any introductory information (especially since it's a one-line abbreviation of the XSudo standard).

In practice I wanted to highlight how the cells are obtained where the sixteen digits in the links must be inserted in the solution.

Again, a noble intention, but I think it has the same problem I complained about the whole MSLS concept. It mixes two things that should be kept separate: the pattern itself and one possible process to find it. As a reader I'm primarily interested in the former because it's an invariant, and I'd like it to be in a generic format that is easily understood and verified without knowing any pattern-specific details (in this case MSLS or SK-Loops). Any extra information describing the pattern or how it was found is a bonus, but it shouldn't blur the structure itself which can often be found and seen in many ways.

It's clear from many examples that the concept of separation of concerns was sometimes difficult for David, even though he championed many other good principles. That's why I have real difficulties reading some of his stuff, because they often have his own personal spreadsheet tricks and stuff mixed in instead of clearly defining the core concept itself. I may (or may not) be interested in such implementation details but only after I've understood the idea first. As it turns out, such generic specification of the MSLS patterns doesn't even seem to exist, because mostly the available information concentrates on the process of finding special cases of them. The big picture is missing.

The term "1379N28 28N1379" is precise,

Well, it only describes the truths precisely, but it surely needs the links too to mean anything. See above for the complete picture.

it indicates exactly the result of this operation

Only half of it. But you're right that finding those cell truths is clearly the goal of the MSLS process because it starts with assuming the links. I think I've finally figured it out. It's inverted set logic which starts with crossing links for all nine digits to find the cell truths at their intersections, and then balances them if possible to find a Rank 0 pattern with cells as truths and houses as links. Simple and effective. Why didn't David say it like that? (Of course that process doesn't find simpler MSLS patterns that don't use all nine digits etc, which is why many people probably don't count them as MSLS. That's why the two should have been defined separately.)

Needless to say, such a result is best described as standard truths and links which are trivial to read from the found pattern (the truths being the found intersection cells and the links being the home and away sets, or an adjusted combo of those). Any attempt to describe the resulting pattern otherwise just complicates things.

in fact it is linked to the logic of XSudo (base sets, cover sets).

Exactly. Which is precisely why I don't like if the term "base" is used for anything else in this context (especially for something that is actually closer to a cover set!).

Surely "Home: (1349) r28, c28. Away: (25678) b1379) ”is more precise because it indicates exactly the digits sets and the areas where to insert the missing ones present in the links.

You can't compare the two like that because the former is missing the links and without them it means nothing! If they're added, it's clearly the more precise and generally useful. The latter only means something to someone who knows MSLS in detail, and it's still hard to rebuild the pattern with just that information. On the other hand, the XSudo notation works for anyone who understands generic set logic even if they've never heard of MSLS (or even used XSudo like me). Both is best when describing MSLS patterns, but if only one of them is presented, I think it should be the generic one.

In general, I hate pattern-specific notations (including those for things like ALS-XZ, ALS-XY, Sue de Coq etc) as the only description, because they're usually more verbose and less informative than the generic ones (AICs, set logic) and require the reader to know that specific pattern and its proprietary notation. That said, they may be useful in describing the philosophy behind that particular POV which might help spotting such patterns, but they're usually not good at describing the pattern itself concisely and precisely. The MSLS notations I've seen aren't particularly good at either.

[SpAce]

Hi champagne!

That said, I actually found a relatively decent definition of Multi-Fish, so I have to (at least partly) absolve champagne

Just considering my poor English language level, I take this as a compliment

Yes, it was meant as one I've previously complained about both MSLS and multi-fish having no clear definitions, but now I think that complaint is only valid for MSLS. Well, almost only

I would be even happier with a more precise definition of multi-fish too. It seems that they're quite inclusive as well, which makes it hard to know exactly which patterns should be counted as such or not. The general idea seems to be Rank 0 patterns with row and column truths, which is easy, but then it gets blurrier when cells are accepted as truths (like where is the line, how many are accepted?). What about boxes as truths?

If I looked correctly, even triplets are included. That complicates things a lot as such patterns are pretty much impossible to use without something like XSudo. For example, I can't quite understand your "most useful seen rectangular pattern" (in the above link) because of the link triplet in r9c5:

.....67...5.1...3...9.2...42..........8.4...29.46..........7.6....3..1..8.......5;11.30;1.20;1.20;elev;318;G3

Code: Select all

sets
1367R3 1367R9 1367C5 1367C9 r4c2 r5c2 r6c2
linksets
1367C2 37B2 16B3 16B8 37B9 r3c1 r4c5 r4c9 r6c5 r6c9 r9c3 r9c5

Without the link triplet I would see 23 eliminations, but now I don't really know which ones are valid because triplet logic makes my head spin. Actually I do know because I checked and it seems that 22 are valid (but does the fish justify them?) and one isn't (1r7c5). Unless I've misunderstood something, or you can explain a simple way to see that, I don't think complex patterns with triplets really work for manual players.

Btw, Phil's solver doesn't see a multi-fish there but it finds an MSLS with almost the same eliminations (20).

I also tried my hand with actually finding an MSLS manually (for the first time without any hints) and succeeded easily, even though it required a minor balancing act. David's process really works, and for that I have to give a lot of credit to him! It's very easy and quick to work out with Hodoku coloring tools.

I chose:

Home (2489)c1359
Away (13567)r1278

Got this at first but it was Rank 1:

16x17 (Rank 1): {1278N1359 \ 135r1 67r2 135r7 567r8 4c1 2c3 89c5 89c9}

Fortunately it was easy to see that the 5s could be covered with just two sets, so I got:

16x16 (Rank 0): {1278N1359 \ 13r1 67r2 13r7 67r8 4c1 2c3 589c5 89c9 5b7} => 20 elims

That was fun! It's the same exact result as Phil's solver's, but I only checked that afterwards, so no cheating.

But more on Allan Barker very efficient Xsudo program. I tried years ago to understand with Allan's help how the program worked and I had the opportunity to meet him in Bangkok. As Allan left interest in this field, we have small chances to see him contributing to the discussion.

Yes, it's a pity that many giants have left long before I joined. Glad some of you are still here!

As such, Xsudo appears as a kind of universal tool to check a given group of sets.

Yes, it seems really good based on the documentation (that's how I've learned to understand set logic at all) and people's comments. I really have to get my hands on it at some point.

The AUR threat was introduced later (very efficiently) by Allan when "abi" described this loop clearing many cases in the "Exocet patterns".

It would be great to know how exactly it uses them, as it's not documented on the site. I would imagine it should be similar to how the other "dark logic" stuff is described, with guardians as a virtual set.

Speaking of a rank 0 logic, the Xsudo notation has the huge advantage to be clear and well known.
Any alternative way to describe the truhs/links should help the reader to better understand why eliminations/assignments are valid.

Exactly. Personally I don't think there is any better alternative when set logic is used, but there could be additional explanations for specific patterns.

Personally, I don't like (I have difficulties with..) the 28N1379 notation, I use instead rxcy for the cells truths (eg r12c4 for the cells r1c4 and r2c4)

I understand that, and I have no trouble reading your set logic notation. The N-notation confused me also for a long time until it started to make sense. I do think it has clear advantages because it makes it crystal clear that cells are meant. When the rYcX notation is used, it's easy to mix with row and column sets.

Philosophically, the N-notation is also in line with Allan's (and Denis') 3D-way of viewing the grid, which I've also adopted a long time ago. I sometimes solve puzzles in the nr- or nc-spaces for fun, and in some cases it's even easier (though Denis claimed it should be impossible because they don't have boxes -- but that's not true, boxes are almost easier to use in those spaces once you figure it out).

I stay strictly in truths/links mode

That's good!

[champagne]

I would be even happier with a more precise definition of multi-fish too. It seems that they're quite inclusive as well, which makes it hard to know exactly which patterns should be counted as such or not. The general idea seems to be Rank 0 patterns with row and column truths, which is easy, but then it gets blurrier when cells are accepted as truths (like where is the line, how many are accepted?). What about boxes as truths?

If I looked correctly, even triplets are included. That complicates things a lot as such patterns are pretty much impossible to use without something like XSudo. For example, I can't quite understand your "most useful seen rectangular pattern" (in the above link) because of the link triplet in r9c5:

.....67...5.1...3...9.2...42..........8.4...29.46..........7.6....3..1..8.......5;11.30;1.20;1.20;elev;318;G3

Code: Select all

sets
1367R3 1367R9 1367C5 1367C9 r4c2 r5c2 r6c2
linksets
1367C2 37B2 16B3 16B8 37B9 r3c1 r4c5 r4c9 r6c5 r6c9 r9c3 r9c5

Without the link triplet.... I would see 23 eliminations, but now I don't really know which ones are valid because triplet logic makes my head spin. Actually I do know because I checked and it seems that 22 are valid (but does the fish justify them?) and one isn't (1r7c5). Unless I've misunderstood something, or you can explain a simple way to see that, I don't think complex patterns with triplets really work for manual players.

Btw, Phil's solver doesn't see a multi-fish there but it finds an MSLS with almost the same eliminations (20).

Hi Space,

I see several sub topics here, I comment first on points needing no research on my side.

As I wrote earlier, a "Rank 0" logic is generally speaking a set/cover; truths/links balanced system where the eliminations are clear.
The target was at the start to define sub families of this group easier to produce (using a computer or "by hand").

A Rank0 logic can not contains triple points. We have a triple point in Xsudo terminology when a candidate belongs to 2 truths or 2 links. This is not valid in the final truths/links status.

But the rank 0 logic is still too general to define an easy (and partial) process to detect them. I focused first on the multi-fish family.

In a multi fish family, all truths contains exclusively a limited number of digits. One practical reason to choose first this sub family was that it is not too hard to apply a brute force to a PM where all other digits are merged and to see if eliminations/assignments appear.

But this sub family is still too large and the experience showed that in many cases, the rank 0 truths logic had three main sub families

A) rows + cells
B) columns + cells
C) 2 rows x 2 columns + cells (typical Easter Monster" pattern).

BTW other sub families could be discovered.

To answer more specifically to your remark on added cells, to be a truth, a cell
must contain only digits of the multi fish
can not belong to the base truths.
This does not give many possibilities.

In the 2rows x 2columns family, in most cases, the crossing cells are solved. Defining a Rank0 logic with no triple point in links seems very hard if one is not.

To comment on your example, I have to work a little on it, but I give you a clue.It is possible that to see the rank0 logic you have first to make basic moves.
The point where you stop basic moves will change the scope.
Normally, as far as I remember, I push the basic moves till XYZ wing before the start of the search of the rank0 multi-fish pattern

Last but not least, when you see a set (A;B;C) as "having some potential for a rank0 logic", you have still many ways to build the links and we have seen quite different results, with or without boxes ...

Normally adding extra cells as truths and choosing between cells links or digits cells links is done at worth optimizing each band/stack status

[champagne]

Hi again SpAce,

No doubt, the pointed example is not correct considering the rank0 multi-fish logic. I suspect the Exocet to explain partly why it works. I have a bug in the program surely linked to the fact that I tried to open the code to a rank1 logic.

As a conservative quick action, I added a warning in the post. I have to give another example later.

Thanks for the debugging work

[eleven]

Home (2489)c1359
Away (13567)r1278

Got this at first but it was Rank 1:

16x17 (Rank 1): {1278N1359 \ 135r1 67r2 135r7 567r8 4c1 2c3 89c5 89c9}

Fortunately it was easy to see that the 5s could be covered with just two sets, so I got:

16x16 (Rank 0): {1278N1359 \ 13r1 67r2 13r7 67r8 4c1 2c3 589c5 89c9 5b7} => 20 elims

That was fun!

Thanks for those 5 lines, SpAce. I never bothered to read about MSLS, because i thought, it is useless to search for one manually.
So i did not understand the (your) notation too. But looking at this for 15 minutes made it clear.
And yes, it could be found manually - though i would have to be very bored to try it.

[Added:] This base/cover, home/away thingie only confused me. If you have 16 digits in 16 cells, you can eliminate them outside in the units, wherever one is restricted.
So what is this distinction for ?

[SpAce]

Hi champagne,

A Rank0 logic can not contains triple points. We have a triple point in Xsudo terminology when a candidate belongs to 2 truths or 2 links. This is not valid in the final truths/links status.

Or would it be more accurate to say that such a pattern can't have global Rank 0? Surely the triple points can gang up and produce local Rank 0 regions, which apparently explains some of JExocet eliminations too. I can sort of understand that with such small scale eliminations, but something like totuan's earlier example with a raw rank of 10 and yet 37 eliminations seems pretty incredible. It does have a lot of triple points so I'm suspecting they must create at least some Rank 0 regions to get all those eliminations, because I don't see a lot of overlapping covers on them.

Anyway, I guess multi-fish and MSLS are supposed to be pure global Rank 0 patterns only, which makes them accessible to human solvers. Thanks for that confirmation!

In a multi fish family, all truths contains exclusively a limited number of digits.

That seems like a significant difference between multi-fish and (the typical) MSLS as the latter uses all nine digits? So, I guess I was wrong when I thought that any (hidden) MSLS that uses houses as truths is also a multi-fish. Thanks for that clarification! Btw, to be precise, what is the max number of digits to count something as a multi-fish?

But this sub family is still too large and the experience showed that in many cases, the rank 0 truths logic had three main sub families

A) rows + cells
B) columns + cells
C) 2 rows x 2 columns + cells (typical Easter Monster" pattern).

BTW other sub families could be discovered.

Ok, thanks! So boxes aren't currently used as truths in any multi-fish configurations? But if such patterns were found, they could be? I'm trying to chart if a defining feature of a multi-fish is that it only uses rows and/or columns as truths (with some cells if need be) or are any house combinations theoretically possible.

To answer more specifically to your remark on added cells, to be a truth, a cell
must contain only digits of the multi fish
can not belong to the base truths.
This does not give many possibilities.

Ok, thanks! I guess that does restrict it enough to keep it as a recognizable pattern despite the cell truths.

No doubt, the pointed example is not correct considering the rank0 multi-fish logic. I suspect the Exocet to explain partly why it works. I have a bug in the program surely linked to the fact that I tried to open the code to a rank1 logic.

Ok, thanks for the confirmation! I couldn't tell if it was my limited understanding or a real problem with the pattern.

Thanks for the debugging work

No problem! Glad I asked about it. Now I can rest assured that all valid multi-fish are indeed pure Rank 0 patterns.

[champagne]

Hi SpAce"

Anyway, I guess multi-fish and MSLS are supposed to be pure global Rank 0 patterns only, which makes them accessible to human solvers.

This was the basic idea focusing on the rank 0 logic.

what is the max number of digits to count something as a multi-fish?

the answer is a practical view. 4 digits is likely the maximum for a human solver. In fact, often, a 5 digit multi-fish gives the same eliminations as another 4 digits multi fish.

It seems to me that the right answer is more on the truths size (valid also for MSLS). In a human rank 0 logic (forget our friend "ttt" he can produce non human solutions) the truths size to search is in the range 12/20