The New Sudoku Players' Forum

[SpAce]

The sue de coq has 4 restricted commons 1256 which leaves the overlaping r4c23 cells as not able to contain digit 9 which locks it to 2 sectors. Sue de coqs technically are also aals rules see ronks comments in previous provayed links 2sectordds and als. Thread)

If you refer to someone's specific comments you could simply link to them directly. Vague references are really annoying. In any case, I guess you meant ronk's examples here:

Here are three examples where both sets B (CB) and C (CR) contain the same digit.

...and hobiwan's attempt at an extended definition allowing such cases here:

Crucially, no candidate from V is allowed to appear in VB and VR.

Do you see how hobiwan's extension and ronk's examples are different from yours? The answer: the 9s in your example are part of V, i.e. digits in the intersection. That's not what ronk or hobiwan had in mind, at least in those posts. The intersection digits can't exist in multiple sectors even with the extended rule which allows other digits to be repeated (which by the way is implemented in Hodoku). Personally I don't really like even that lesser extension because it breaks the purity of a "disjoint subset" which should have exactly N digits in N cells. Any duplication of digits results in fewer digits than cells in the solution, which is not my idea of a disjoint subset (distributed or not). It's just a generic locked set, i.e. MSLS.

In any case, your further extension is a clear violation of even the extended rule, and it completely destroys the distinction between DDS and MSLS. Such distinctions should be preserved because they allow more exact names and hierarchies for patterns and thus more accurate communication. Every DDS is an MSLS, but not every MSLS is a DDS. Whenever you muddy those boundaries you're increasing local entropy, which is never a good thing. For some reason you have a habit of doing exactly that, which makes unambiguous communication harder and harder because every term can mean just about anything. I'd rather sharpen those boundaries to decrease local entropy.

It's a very good idea to generalize concepts, but it's not a good idea to refer to those generalizations with names that should be reserved for specific subtypes of them. If you do that, there's no longer any way to point to those specific patterns without ambiguity. It's the Turbot Fish problem all over again. If you want to use a single name for all of these types of patterns regardless of their exact subtypes, use MSLS. It's higher up in the hierarchy so it covers Sue de Coqs and other DDS too. You're doing it wrong if you're instead calling generic MSLS patterns Sue de Coqs.

I think your extension is probably what Obi-Wahn called multiplicities:

I have added Multiplicities now to DDS, but it's very slow for puzzles with many empty cells. One thing is that the calculation of multiplicities isn't trivial.
The question is, how many times can the same digit be placed within a given set of cells without violating the Sudoku rules. Or in other terms, what is the least number of sectors that is needed to cover all cells of the set. And this is equivalent to the Minimal Set Cover problem which is NP hard.
The other thing is, that I couldn't find a way for an early search termination. For DDS there can't be more than 9 cells within the set, because every digit is allowed only once. With multiplicities the number of cells is unlimited, so for an exhaustive search all available empty cells must be added. This leads to millions of nodes in the search tree for which multiplicities must be calculated.

It seems pretty clear to me that Obi-Wahn understood and wanted to maintain the distinction between basic DDS and patterns with multiplicities. I do too. In modern times, the proper name for the latter is MSLS.

Eliminations code removes the overlap cells from sets a and b so box 5 eliminations are justified

Exactly, but just like you wrote, it's two separate steps that must happen sequentially in a specific order. Thus they are not justified by the ALS-XZ directly. In other words, it's not a single move but two, and pretending something else is extremely confusing. With your ALSs, the bundled box 5 eliminations are a side-effect that can only happen after the 9s in r4c23 are eliminated. As a programmer you should know that side-effects are generally a bad idea, especially if they're totally unexpected like here. You should only list eliminations that can happen in parallel (in any order) and are directly justified by the logic of the presented move.

If your ALSs are (12569)r4c2346 and (169)r45c1, with candidates of 9 in every cell of the pattern, there's no way that the 9s can get locked in such a way that they could directly eliminate 9r6c46. It's simply impossible. If you instead use ALSs (12569)b4p2347 and (259)r4c46 the 9s get locked in r4c46 which can eliminate 9r6c46. Thus, even though the underlying pattern of cells and candidates is the same and can indeed justify the box 5 eliminations, the logic of your presented move can't. They're two distinct things.

Same thing happens in the als... But im not going to list nuances of solving code.

This has nothing to do with coding. The logic should be the same whether it's coded or done in the brain. To get the box 5 eliminations with those ALSs, your code must be doing sequential eliminations within the move, or otherwise there's something more seriously wrong with it. Either way, it shouldn't.

Following them blindly no, just using more thorough elimination code then hodoku.

Nothing wrong with that as long as the additional eliminations are justified by the presented move. An example of that would be the valid cannibal eliminations which your solver sees but Hodoku doesn't. That's good. However, the box 5 eliminations are not valid as presented, so you appear to be overdoing it. (As usual, I keep an open mind to the possibility that I'm just blind to something, but in that case you should show what it is.)

Canabolistic als moves probably not the correct thread mostly investigated by paul
http://forum.enjoysudoku.com/als-chains-with-overlap-cannibalism-t6580.html?hilit=Paul

Ok, thanks. I'll check it out at some point.

[StrmCkr]

4 locked cells from rc 1256: with 2 cells locked for digit 9: includes the internal cannibalistic eliminations and the b5 eliminations as the locals of digit 9 outside the overlap are used for eliminations as the overlap are Locked to holding the rc exclusively.
which is 6 digits 6 cells, 1 digit repeating still. A sue do coq by that definition. N digits in N cells with N digits locked to n sectors. But ill digress on the sue do coq topic for now as the 9s clearly are in the overlap.

Is it the turbo fish all over again, no. The difference is i write one code that applies all eliminations for the formations
Instead of writing multiple different named techniques with slightly different elimination rules. But same search engine.
Or modifying its search function for specific case types.
Like min max ers when 1 code finds all, even if it meant then code also found another fish that happens to form on the same spot. Ie overlapping technique names.

I get your point on it, i really do its this all over again

Code: Select all

 
1234 1234.123456789 |  124  124 123456789 | 123456789 123456789 123456789 |

Take the naked quad, most solvers code would only applies the eliminations to the row and follow it with a blr for digit three on box 1.

Mine did both at one point in time and called it a naked quad. Even though its a n set in n cells they never considered eliminating the internal set parts as individuals so i went the forums opinion and use 2 moves instead of one.

Now as for my own code i have time to digest your post better and see if my code finds the same results instead of the three i tried it in. As mine is slower and a catch all with limited display tool is harder to use but i can narrow its search n size down with code editing.

http://forum.enjoysudoku.com/yzf-sudoku-t36846.html is where i sourced it from which is a re written copy of hodoku, i cross checked it with hodoku and xsudoku and found them in both pasted the results.

I get how the eliminations work and your concerns on extended elimination scenarios: so ill cross check my own work and find out if i hit the same things or if its a bug in yzf's coded.

Anyways off to check and repost my reacted work if i find something.

Keep in mind i reedit my posts a lot, and if you find mistakes pm me first so i can review. My errors and update my oversights before. Beguiling me.as i have said in the past takes a lot of effort for me to post coherent consist posts.

[SpAce]

Hi StrmCkr,

I'll get back to this later, but one clarifying question for now.

Xyzs solver is where i sourced it from which is a re written cooy of hodoku, i cross checked it with hodoku and xsudoku and found them in both pasted the results.

Are you saying that your copy of standard Hodoku found a Sue de Coq and reported all of those eliminations for a single SDC/ALS-XZ move? If so, can you post screenshots of those moves? My copy of Hodoku surely can't find such creatures (or any Sue de Coq) in that puzzle.

Keep in mind i reedit my posts alot, and if you find mistakes pm me first so i can review. My errors amd upate my oversigtes befor. Begiling me.as i have said in the past takes a lot of effort for me to post coherent consist posts.

Ok. Make no mistake -- if and when I question something, I'm not trying to make anyone look bad. Personally I think these kinds of discussions are the most educational, both for the participants and their audience. At least I prefer to read those historical discussions where mistakes were made and concepts were being argued back and forth. That's how things evolve. It's much more interesting than ready-made facts spoon-fed by some "authority" -- especially since those facts are rarely flawless.

Such discussions also force everyone to think harder and question their own assumptions. I've already found at least one falsehood in my own assumptions during this discussion. I always thought that any Sue de Coqs and DDSs had exactly N digits in N cells, but that's not true with hobiwan's extended definition which is implemented in Hodoku. It's interesting that I never realized that before. (I still think those extended forms should be called something else.)

[StrmCkr]

xsudoku, yzf's solver - cross checked the eliminations they appear on both these solvers

hodoku - nope cant find it on a re check... ill chalk that up to more human error....

hodoku and mine are the following: {with double linked code enabled and no extra stuff}

code i used to generate the test case:

Code: Select all

+---------------------------------+---------------------------------+---------------------------------+
| 123456789  .          .         | .          .          .         | .          .          .         |
| 123456789  .          .         | .          .          .         | .          .          .         |
| 123456789  .          .         | .          .          .         | .          .          .         |
+---------------------------------+---------------------------------+---------------------------------+
| 123456789  12569      1259      | 59         123456789  259       | 123456789  123456789  123456789 |
| 69         123456789  123456789 | 123456789  123456789  123456789 | 123456789  123456789  123456789 |
| 19         123456789  123456789 | 123456789  123456789  123456789 | 123456789  123456789  123456789 |
+---------------------------------+---------------------------------+---------------------------------+
| 123456789  .          .         | .          .          .         | .          .          .         |
| 123456789  .          .         | .          .          .         | .          .          .         |
| 123456789  .          .         | .          .          .         | .          .          .         |
+---------------------------------+---------------------------------+---------------------------------+


Almost Locked Set XZ-Rule: A=r4c2346 {12569}, B=r56c1 {169}, X=1,6 => r4c1,r5c23,r6c23<>6, r1234789c1,r4c5789,r5c23,r6c23<>9, r4c1,r5c23,r6c23<>1, r4c15789<>2, r4c15789<>5

als xz 1

capture3.PNG (6.57 KiB) Viewed 1018 times

Almost Locked Set XZ-Rule: A=r4c46 {259}, B=r4c23,r56c1 {12569}, X=2,5 => r4c15789<>5, r4c15789,r5c23456,r6c23456<>9, r4c15789<>2, r4c1,r5c23,r6c23<>1, r4c1,r5c23,r6c23<>6

als xz 2

Capture2.PNG (6.97 KiB) Viewed 1018 times

here is my screen shots from my own code that shows the eliminations:

my double linked xz - elimination run time.: Show

Code: Select all

 if   popcnt(dword(z1)) >1  { triggers doubly linked rules }
                        then
                    begin
                          active:=true;

                                                     {set a&B is now a locked set removal peers cells visible to all copies of each digit in  both sets}
                                                  for R in comboset[yn2] + comboset[yn4] do
                                        for q in ([0..80] * digitcell[R]) do
                                         begin {R/Q elimiantion search}

                                         if (R in (comboset[yn2] * Comboset[yn4]) ){search for common digit to both, and active in both}
                                         and ((digitcell[R] * combosets[xn,yn])  <> [] )
                                                      and ( (Digitcell[R] * combosets[xn2,yn3])  <> [])
                                         and (Peer[q] * ((Combosets[xn,yn]+Combosets[xn2,yn3])*digitcell[R]) = ((Combosets[xn,yn] + Combosets[xn2,yn3])*digitcell[R])) {makes sure the peer of q can see all the digits}
                                          and ([q] * (Combosets[xn,yn] + combosets[xn2,yn3]) = []) {q cannot elimiante from a set cell}
                                            then
                                           begin
                                             covered2[R]:=Covered2[R] - [q];

                                          if k =0 then
                                             begin
                                                             techwrite[u,r]:= techwrite[u,r] + [q];
                                                             techwrite[u,14]:=techwrite[u,14]+[R];
                                                           end;

                                            end;
                                           
                                            {cells in set A for digits exclusively to A and not in z1  their peers cannot contain r}
                                          if (R in (Comboset[yn2] - z1) )
                                          and  (peer[q] * Digitcell[R] * Combosets[xn,yn] = combosets[xn,yn] * Digitcell[R])
                                          and ([q] * combosets[xn,yn] = [])
                                            then
                                             begin
                                             covered2[R]:=Covered2[R] - [q];
                                             if k =0 then
                                             begin
                                                             techwrite[u,r]:= techwrite[u,r] + [q];
                                                             techwrite[u,14]:=techwrite[u,14]+[R];
                                                           end;
                                             end;
                                             {cells in set B for digits exclusively to B and not in z1  their peers cannot contain r}
                                          if (R in (Comboset[yn4]  -  z1) )
                                          and  (peer[q] * Digitcell[R] * Combosets[xn2,yn3] = combosets[xn2,yn3]* Digitcell[R])
                                          and ([q] * combosets[xn2,yn3] = [])
                                            then
                                             begin
                                             covered2[R]:=Covered2[R] - [q];
                                             if k =0 then
                                             begin
                                                             techwrite[u,r]:= techwrite[u,r] + [q];
                                                             techwrite[u,14]:=techwrite[u,14]+[R];
                                                           end;
                                             end;


                                         end; {R/Q elimiantion search}

hodoku double linked rule: operates slightly incorrectly
the locked set portion cant remove candidates from any of the selected als cells even if its applicable.
--- it misses cannibalistic : minor oversight.

to be continued later:

[eleven]

Code: Select all

        +---------------------------------+---------------------------------+---------------------------------+
        | 123456789  .          .         | .          .          .         | .          .          .         |
        | 123456789  .          .         | .          .          .         | .          .          .         |
        | 123456789  .          .         | .          .          .         | .          .          .         |
        +---------------------------------+---------------------------------+---------------------------------+
        | 123456789  12569      1259      | 59         123456789  259       | 123456789  123456789  123456789 |
        | 69         123456789  123456789 | 123456789  123456789  123456789 | 123456789  123456789  123456789 |
        | 19         123456789  123456789 | 123456789  123456789  123456789 | 123456789  123456789  123456789 |
        +---------------------------------+---------------------------------+---------------------------------+
        | 123456789  .          .         | .          .          .         | .          .          .         |
        | 123456789  .          .         | .          .          .         | .          .          .         |
        | 123456789  .          .         | .          .          .         | .          .          .         |
        +---------------------------------+---------------------------------+---------------------------------+

The eliminations are easily found with my standard observation:
5 digits in 6 cells -> at least one must be twice. This can only be the 9 in r4c46 and r56c1.
So the 9 must be in these cells, and all other digits in the wing cells: 1r4c23,r6c1; 2r4c236; 5r4c2346; 6r4c2,r5c1.

[Added:]
This is my way to manually find and check these patterns:
If i can find n digits (normally 4 or 5, maybe 6) in n cells, i look which can be twice (or triple), i.e. are in different units:
If none can be twice, all digits must be in these cells.
If only one can be twice, it must be in the wing.
If two can be twice (and not one of them triple), i look for a common outcome of them being twice.
If there are n digits in n+1 cells:
If only one can be twice, it must be twice, and the other digits in the wing cells.
If two can be twice, i look for a common outcome of them being twice (if they would exclude each other, the other digits must be in the wing cells)

[SpAce]

Hi eleven,

Glad you joined the discussion, too.

The eliminations are easily found with my standard observation:
5 digits in 6 cells -> at least one must be twice. This can only be the 9 in r4c46 and r56c1.
So the 9 must be in these cells, and all other digits in the wing cells: 1r4c23,r6c1; 2r4c236; 5r4c2346; 6r4c2,r5c1.

Yep. All of the eliminations are available at once with that elegant piece of logic. I have no problem with that.

The question is: can you express it simply (or at all) with any of our standard moves and formal notations? Not so easy, I'm afraid. For me it's the test whether it can be called something like Sue de Coq or even generic DL-ALS-XZ like StrmCkr claims. For me part of the definition of both moves is that they can be written as simple ALS-Loops. Here I can't write one that would produce all of the eliminations at once. I kind of doubt that anyone can (but would be happily proved wrong).

The closest to a single expression I can come up with is this triply siamese mixed rank cannibal fish:

6x6 (Rank 0/1): {56N1 4N2346 \ 16b4 25r4 [9r4c1|9b45|9r4b4]} => -16b4, -25r4, -9r4,c1,b4,b5 (Rank 0); -9 r4c23 (Rank 1, cannibal)

I don't think it really counts, though. What I really want is a single (and preferably simple) AIC-Loop and/or a matrix that would prove all the eliminations. The crucial part of it is that it should prove that 9 gets locked in both r56c1 and r4c46. It's relatively easy with a dual DP, but I think it counts even less:

DP[(259)r4c2346 | (169)b4p2347] = (1|6 & 2|5)r4c23 - (16|25)r56c1,r4c46 = (9)r56c1&r4c46 => [-16b4, -25r4 ?], -9r4,c1,b45 (including r4c23)

Can you turn that into an AIC-Loop that retains all of those eliminations? I can't. I still think it requires two moves. Furthermore, even though the above does lock the 9s where we want them, the 16b4 and 25r4 eliminations aren't obvious or perhaps even directly justified by it.

If no one can turn it into a single AIC-Loop, then I don't think all of those eliminations can be reported for any single standard move, certainly not a Sue de Coq (which I don't think exists here anyway) or even a generic DL-ALS-XZ. Like I said, I think both moves have (or should have) the intrinsic property that they can be written as a simple AIC-Loop.

That said, I don't see much of a practical need to get all those eliminations at once, since basics take care of the mop-up work after either of the available standard DL-ALS-XZ moves. That's how I'd do it in practice, and I think it's the simplest approach -- unless you figure out a way to formalize your logic. As you know, I'm not happy if a piece of logic can only be expressed in words. It means that either our palette of named techniques and notations lack expressive power or we lack the skill to use it.

[Added:]
This is my way to manually find and check these patterns:
If i can find n digits (normally 4 or 5, maybe 6) in n cells, i look which can be twice (or triple), i.e. are in different units:
If none can be twice, all digits must be in these cells.
If only one can be twice, it must be in the wing.
If two can be twice (and not one of them triple), i look for a common outcome of them being twice.
If there are n digits in n+1 cells:
If only one can be twice, it must be twice, and the other digits in the wing cells.
If two can be twice, i look for a common outcome of them being twice (if they would exclude each other, the other digits must be in the wing cells)

Nice algorithm. Most of these cases are covered by standard patterns and expressible with standard notations as I've sometimes demonstrated, but what we have in this example is not if all of the eliminations are wanted at once. Or at least I can't do it. That's why this is an interesting case.

[SpAce]

Hi StrmCkr,

xsudoku, yzf's solver - cross checked the eliminations they appear on both these solvers

So they're the culprits. Shame on them!

hodoku - nope cant find it on a re check... ill chalk that up to more human error....

Thanks for confirming that. I would have been really baffled had the opposite been true.

hodoku and mine are the following: {with double linked code enabled and no extra stuff}

Almost Locked Set XZ-Rule: A=r4c2346 {12569}, B=r56c1 {169}, X=1,6 => r4c1,r5c23,r6c23<>6, r1234789c1,r4c5789,r5c23,r6c23<>9, r4c1,r5c23,r6c23<>1, r4c15789<>2, r4c15789<>5
Almost Locked Set XZ-Rule: A=r4c46 {259}, B=r4c23,r56c1 {12569}, X=2,5 => r4c15789<>5, r4c15789,r5c23456,r6c23456<>9, r4c15789<>2, r4c1,r5c23,r6c23<>1, r4c1,r5c23,r6c23<>6

So your own code does need two separate moves for all the eliminations, just like Hodoku and myself? You should congratulate yourself! I think it's the only correct way to do it with standard moves (i.e. something like eleven's logic excluded). I can imagine how XSudo gets them by using several combos of cover sets (like I did), but I can't see how the YZF solver justifies them. As far as I'm concerned, both are wrong if they call the pattern a Sue de Coq.

hodoku double linked rule: operates slightly incorrectly
the locked set portion cant remove candidates from any of the selected als cells even if its applicable.
--- it misses cannibalistic : minor oversight.

Well, I guess it's a matter of taste whether cannibal eliminations should be included in a standard DL-ALS-XZ move or not. It's true that they're justified by the move, but as Rank 1 eliminations they're not similar to the others.

[yzfwsf]

but I can't see how the YZF solver justifies them.

Sue de Coq is rank 0 logic,in this Sue de Coq digit 9's must have 2 links,can be 9b4r4 or 9b45 or 9r4c1,so r1c1<>9 r4c2<>9 r4c3<>9 r5c2<>9 r6c4<>9 r6c6<>9 r9c1<>9

[StrmCkr]

Standard dl als rules covered above space, elevens speciation are disabled for the continume which catches the other ones.
- hopefully i can post that tonight.

[SpAce]

Hi yzfwsf,

Nice of you to join as well.

Sue de Coq is rank 0 logic,

Of course it's Rank 0 logic, but not every Rank 0 pattern is or should be called Sue de Coq. I'm interested in what exact definition you're using for that name and where you found it. It's the widest definition I've seen. It definitely doesn't conform with the original or the DDS generalization or even hobiwan's extension (implemented in Hodoku).

Personally I prefer the original tight definition which is always N digits in N cells where none can be twice. Any other cell-based Rank 0 pattern is to me a generic MSLS (or more specifically MSNS) which is the parent type of DDS (and DDS is the parent type of SDC). If you call all of them Sue de Coqs, the whole naming hierarchy breaks and there's no way to separate the more specific types from the generalized types. I don't think that's a good thing, as I've explained before. At the very least the patterns using the looser definitions should be called Extended SDCs or something to indicate they're different from the classic type.

in this Sue de Coq digit 9's must have 2 links,can be 9b4r4 or 9b45 or 9r4c1,so r1c1<>9 r4c2<>9 r4c3<>9 r5c2<>9 r6c4<>9 r6c6<>9 r9c1<>9

That's exactly the set logic representation I wrote:

6x6 (Rank 0/1): {56N1 4N2346 \ 16b4 25r4 [9r4c1|9b45|9r4b4]} => -16b4, -25r4, -9r4,c1,b4,b5 (Rank 0); -9 r4c23 (Rank 1, cannibal)

Like I said at the very beginning, and you now confirmed, it needs three different combos of cover sets to get all the eliminations. That's basically similar to a siamese fish. Note that the cannibal eliminations (r4c23) are not Rank 0 but Rank 1.

It surely works as a siamese cannibalistic mixed rank set logic, but I wouldn't call it Sue de Coq. It's quite a bit more complicated than the classic type or even the Hodoku extension (which allows duplicated digits but not in the intersection). Unlike the classic or even the extended Hodoku types, it can't be written as an ALS-Loop (or it can, but it just doesn't get all the eliminations in one stroke). That alone puts it in a more generalized class, imho.

[yzfwsf]

Hi space:
I confirm a pattern as Su de Coq, it seated in one line and one box, the final candidates of intersect cells must be one same line-cell's and one same box-cell's.

[SpAce]

I confirm a pattern as Su de Coq, it seated in one line and one box, the final candidates of intersect cells must be one same line-cell's and one same box-cell's.

Ok. But you didn't answer my other question: where did you find that definition? If you looked at my links, you should have noticed that it's clearly much looser than the original or even hobiwan's extended definition, identifying many more patterns as Sue de Coqs than those. In other words, if you have no reference for it, you've pretty much created your own definition which is in conflict with everything else out there. Or is your reference XSudo, as StrmCkr implied that it also calls the same pattern Sue de Coq? If so, then those two are the only ones I know that use such a wide definition of SDC. (I probably wouldn't use XSudo as a naming reference despite its other qualities.)

I'm not judging whether your definition is good or bad, just that it's different from everything else I know, which makes accurate communication hard. I would prefer that names meant pretty much the same thing for everyone. Otherwise they stop having any meaning, and one has to attach the applied definition whenever they use a name for some pattern.

Since your definition is in the clear minority, I would suggest you used a different (or qualified) name for your extended versions to separate them from the classic Sue de Coqs which don't allow repeated digits (especially if they're also in the intersection). Otherwise you're creating confusion by using a name that most other people interpret differently. Of course you're free to do whatever you want, but that's my opinion. There are enough illogical hierarchies and conflicting names and definitions in the sudoku namespace already.

Think about the logic of the original name of Sue de Coq: "Two-Sector Disjoint Subset". A normal (One-Sector) Disjoint Subset (e.g. a naked quad) can't have more than one instance of any digit because they all see each other automatically. So, there must be N digits in N cells where none can be twice. The original idea of Two-Sector Disjoint Subsets and the generalized Distributed Disjoint Subsets (i.e. using 3+ sectors) was to extend that idea to more than one sector while maintaining the same rule: N digits in N cells where none can be twice. It also meant that the max number of cells in a DDS was nine because no digits could be repeated. While other useful configurations are possible with repeated digits, that was the given constraint for those named patterns making them easy to identify. If repeated digits are allowed, then they're no longer the same patterns but something else (MSLS). I'm repeating myself, but here's Obi-Wahn's definition for generic DDS:

The rule can be put very simple:
A subset of N cells sharing only N different digits is disjoint, if all occurrences of the same digit share one common sector.
This means that none of the N digits can be true more than once in the subset, because all instances of this digit within the subset can "see" each other.
Every candidate outside the subset that shares a sector with all occurrences of the same digit within the subset can be eliminated.
This follows because if such a candidate was true, it would eliminate this digit completely from the subset, leaving us with only N-1 digits for N cells.

Since Sue de Coq is a subtype of DDS it should logically follow that definition, just like it originally did. Yours doesn't. How would you define larger Distributed Disjoint Subsets so that your Sue de Coqs would fit under that umbrella? If you try to do that, you end up with MSLS -- which is a cell-based Rank 0 pattern that does allow repeated digits. That's the crucial difference between DDS and MSLS, and your loose definition of SDC has blurred it because it includes generic MSLS patterns instead of just DDS patterns.

[yzfwsf]

Ok, In order not to cause misunderstanding in communication, I will mark cannibalized type.

Sue de Coq.png (64.64 KiB) Viewed 892 times

[SpAce]

Ok, In order not to cause misunderstanding in communication, I will mark cannibalized type.

Ok. I think that's a good idea. It might be enough for the SDC dilemma. However, if I understood correctly, you also list the same eliminations for a single DL-ALS-XZ. I don't think that's correct, for reasons explained in my responses to StrmCkr. It's not correctable with a name change either, because the problem is not with the cannibal eliminations. The problem is that no single ALS-XZ move can logically eliminate the 9s from both r19c1 and r6c46. You need two different DL-ALS-XZs to get all the eliminations:

ALS A: (169)r56c1, ALS B: (12569)r4c2346, X=1,6 => -69 r5c2, -5 r4c9, -9 r19c1, -9 r4c23
ALS A: (259)r4c46, ALS B: (12569)b4p2347, X=2,5 => -69 r5c2, -5 r4c9, -9 r6c46, -9 r4c23

As ALS-Loops:

(1=9'6)r56c1 - (6=259'1)r4c4623 - loop => -69 r5c2, -5 r4c9, -9 r19c1, -9 r4c23 // X=1,6
(2=9'5)r4c46 - (5=169'2)b4p4723 - loop => -69 r5c2, -5 r4c9, -9 r6c46, -9 r4c23 // X=2,5

--

Btw, a couple of unrelated observations about your visible technique list: Show

Your "Finned X_Wing:6r19c15 fr4c9 => r5c7<>6" appears to be incorrect. Should be 6r15c19, right?

Furthermore, most people would rather call it "Finned Sashimi X-Wing", and the same goes for the other one. I didn't go over all the other fishes, but they probably have similar issues. The "Sashimi" qualifier is pretty important especially with X-Wings, because people expect normal "Finned X-Wings" to look very different (having all vertices). Btw, Hodoku (and many people) would call it just "Sashimi" (implying "Finned" as well) but that's actually slightly incorrect, as a fish can be Sashimi without being Finned. (Without any fins a Sashimi fish degenerates into a smaller fish with basics.)

Thirdly, I would highly recommend using the UFG notation for fishes. When you just list the cells, it's very hard to see how the fish works. Instead you should treat it as set logic because it is. In other words, you should list first the base sets and then the cover sets, with '\' separating them. Thus your Finned X-Wing above should look something like:

Finned Sashimi X-Wing: (6)c19\r15 fr4c9 => -5 r5c7

Lastly, I'd replace your visible X-Chains and Continuous Nice Loops with just two X-Loops:

X-Loop: (7)r5c8 = r5c9 - r9c9 = (7)r9c8 - loop => -7 r6c8,r9c6
X-Loop: (7)r6c6 = r6c4 - r7c4 = (7)r7c6 - loop => -7 r9c6

When an X-Chain loops back to itself it becomes an X-Loop automatically, and there's no real point to call it X-Chain or even list the individual X-Chains it contains -- because it gets all the eliminations at once. Similarly, when a generic AIC loops back to itself it becomes an AIC-Loop. Those are the names you should use for (continuous) loops. Like I said elsewhere, since you're using AICs and Eureka anyway, there's no reason to use any reference to the obsolete Nice Loops (not even Continuous ones). Since all X-Loops and other AIC-Loops are continuous, the "continuous" keyword can be dropped as well. Switching all the way to that modern terminology would be a huge improvement over Hodoku.

Also, you don't need to repeat the start node at the end of a loop if you mark it like I did. The "- loop" at the end implies that it links back to the start node, and it makes it easier to see the relevant chain when the first node is not repeated.

(Btw, your last two "Continuous Nice Loops" are exactly the same loop, just started at different points. You should just list one or the other, not both, because there's no real difference. It doesn't matter where you start.)

[yzfwsf]

if I understood correctly, you also list the same eliminations for a single DL-ALS-XZ. I don't think that's correct

I think a DL-ALS-XZ can eliminate all 9, because DL-ALS-XZ is also a Rank0 logic, not the same SL-ALS-XZ is a Rank1 logic.Rearrange coversets without affecting the final rank, so these combinations can form effective elimination。

Your "Finned X_Wing:6r19c15 fr4c9 => r5c7<>6" appears to be incorrect. Should be 6r15c19, right?

Yes, the last time the string generator was modified introduced with a bug. This bug is now fixed and the display of prefix sashimi is implemented.

Btw, your last two "Continuous Nice Loops" are exactly the same loop

In fact, I didn't code to recheck whether the output was duplicate.