The New Sudoku Players' Forum

[StrmCkr]

How would you resolve the related NxM naming problem?

problem with nxm is that it doesn't use Finns per say any one of the m values could be the fin sector --- so its name can be multiple different types at the same time. {as seen in the mixed type examples}
{having the Finn outside the pattern makes nxn naming easier as the base/cover is clearly outlined }

.....................
alright that clears it up , ill go back and change the mutant tag to franken.

[SpAce]

problem with nxm is that it doesn't use Finns per say any one of the m values could be the fin sector --- so its name can be multiple different types at the same time. {as seen in the mixed type examples}
{having the Finn outside the pattern makes nxn naming easier as the base/cover is clearly outlined }

So how should we deal with it? I suggested using the type of the minimum complexity. A bit easier option might be using just the constant base sectors as the determining factor. For the Turbot variants both methods would yield the same results.

alright that clears it up , ill go back and change the mutant tag to franken.

Glad we got that out of the way. So, let's look at the rank stuff...

X-Wing, frankenr13/c3b13 => r2456789c3<>7, r2c12789<>7

Is from xsudoku and its a rank 0 as
As written and displayed above.

Since I'm not using XSudo I can't confirm that, but I trust it is so. Seems very weird anyhow, because it's not what the XSudo documentation would suggest:

Covering sets are the links that exactly cover the base candidates. A group of covering sets is any group of links containing all candidates in the base sets where no link can be removed and the candidates remain covered. Covering sets are not necessarily exact cover sets because they are allowed to overlap. One group of base sets can be covered by multiple groups of covering sets.

A candidate is eliminated only when it sees other candidates through the same group of covering sets. In other words, rank rules are based on cover groups.

Eliminations occur when one or more links in the same group of covering sets overlap to contain a candidate. Overlap linksets from different cover groups do not cause eliminations.

Counting Rank

When counting rank or searching for a solution of covering sets, two points are considered.

1. The links must form a group of covering sets, i.e., cover all candidates with no redundancies.

SUMMARY

1. Every elimination is based on two groups of sets. The base set group exactly contains a group of candidates and the link set group contains these candidates as well as other candidates that are potential eliminations.
2. The number of links minus the number of base sets is called rank. Rank is a distributed property of the logic and is uniform everywhere within a logical structure except for conditions noted below.

Based on that I would think that XSudo sees our fish having two different cover groups: b13 and c3b3, both having their own eliminations. It's exactly what my Siamese notation depicted. I think it's very confusing if XSudo displays them as a single combined group instead. Even if it does, it doesn't mean that we should.

Rank only increases when the balancing equations do not balance
Same with K values in N X M fish. {name adjusted as per suggested}
as M = N +K, where k is additional sectors used to balance the equation
(their is limitations to what can be used as superfluous covers for increasing k size with out affecting M total value)

I have no idea what "balancing equations" are. Considering how much of the available documentation on the forum and elsewhere I've read, I don't think they can be part of common knowledge either. Thus you can't really use that as support for your claims without providing links to relevant documentation. If it's only about software techniques, I don't care anyway.

in full following obi's math directly {instead of the noted shortcuts i use in my set based version of obis math which cannot reuse sectors}
would be R1133 / c3b133 => r2456789c3<>7, r2c12789<>7 { rank zero }

That I can accept, and I think it's actually a very cool way to get all the eliminations at once without resorting to a Siamese fish. I didn't even think of that possibility, so thanks for that! Obi's rules are well-established and straight-forward, and the rank is easy to count for the combined fish (4-4=0 here). Using Obi's arithmetic it can also be transformed into a normal Mutant Swordfish: R13B2\r2c3b3 with the same eliminations. So, no objections thus far.

and reduces to R13/C3B13 => r2456789c3<>7, r2c12789<>7 and still holds the rank zero as displayed in xsudoku

I don't see how it reduces to that. Not with Obi's rules, nor with documented XSudo rules either. Also, applying Obi's arithmetic on that yields this: B2\r2c3 which makes no sense because c3 has no connection to B2. So, I don't think your reduction achieves anything positive.

However you are correct they won't work in ufg terms and would instead have to be listed as alternatives.
where by and nicely displayed by you

Siamese Franken X-Wing: (7)R13\b3[c3|b1] => -7 r2c279,r78c3
is another great way of doing it

Thank you. I think it's the only way (besides the Obi-trick above) that makes sense, at least for a human solver. Whatever some software solver does internally is irrelevant to me. All that matters to me is that the notation used to communicate the logic should make sense. Writing R13\c3b13 for Rank 0 logic makes no sense, because it clearly implies Rank 1 logic for most people familiar with normal rank counting rules. Even if it does work under special circumstances and exotic rule sets known to few, it's still a bad idea because it just confuses most people. It seems to me that you completely ignore such considerations.

defiantly not a half baked idea, as its been used and implemented by others that is not just me.

That doesn't prove something is not a half-baked idea. Even if an idea is totally awesome but so poorly communicated that few understand or even know about it, it's at most half-baked. I've seen you talk about your fish rules many times, but I haven't seen them clearly documented anywhere, so I can't really pass judgment on them per se. All I know is that you can't refer to them as if they were common knowledge and well-established fact in the same league as the UFG, Obi-Fishes, and Allan Barker's set logic, which are all clearly documented with examples.

[tarek]

This is a bit off topic?

In the following Grid

Code: Select all

+----------------+----------------+----------------+
| 13   a35  4    | 6    78   d1-5 | 78   2    9    |
| 6    2    7    | 14   89   49   | 18   5    3    |
| 8    9    a15  | d57   2    3   | 4    16   67   |
+----------------+----------------+----------------+
| 9    35   158  | 12   3457 6    | 137  48   27   |
| 135  4    568  | 57   357  12   | 9    168  267  |
| 12   7    126  | 8    39   49   | 13   146  5    |
+----------------+----------------+----------------+
| 7    1    b25  | 9    6    8    | 25   3    4    |
| 4    6    9    | 3    1    c25  | 25   7    8    |
| b25  8    3    | 24   c45  7    | 6    9    1    |
+----------------+----------------+----------------+

3 strong links a,b and c ==> r1c6<>5
because r1c6 is strongly linked to r3c4 (d) then we have in theory 2 simultaneous and cannibalistic Fishes here (with r3c3<>5)
Because the share 2 of the 3 strong links, is this is what you refer to as Siamese?

[StrmCkr]

http://forum.enjoysudoku.com/post228274.html#p228274 here is documentation for how my NxM software works its based completely on obiwans math but uses sets instead
thus its limitation is that same sets added to a set results in no change, to over come that i resorted to using the R,C,B intersections to mark increasing K values and derive its eliminations.

I have no idea what "balancing equations"

its the systems used to verify the N Cells in N sectors are locked for every fish and their formations in the ufg guide and else where below is links/references

balancing equation:
{mine} base x cover = base
UFG
obis is direct count check +- system

mine and xsudo derives the same issues we are discussing: rank from the following
rank doesn't increase in xsudo for a lot of stuff not just fish size but it is easiest to notice it especially in larger fish: duplicate/overlapping & base/cover sectors that house identical coverage are "removed internally" by limitations of sets and only displays the base pattern and a corresponding rank following this note

i.e., cover all candidates with no redundancies.

duplicates are removed for the same reason i cannot use them: they change nothing to the initial sets which in ufg/obi terms it does change the fish

you are correct after some reflection on what you wrote:
the easiest way to depict them with out knowing the cravats of set based solver programs is converting it back to obis math. math is the same, one is visible and easier to comprehend one is not as information appears missing when comparing it to other methods/knowledge. like you mentioned here

Also, applying Obi's arithmetic on that yields this: B2\r2c3 which makes no sense because c3 has no connection to B2. So, I don't think your reduction achieves anything positive.

obis math from

R1133 / c3b133 => r2456789c3<>7, r2c12789<>7
R11233/ R2c3b133
R13B123/R2c3b133
R13B2/r2c3b3
R123B2/R22C3B3
B1223/r22c3b3
B122/r22c3

balance is lost in the reduction step that's not apparent or cross check-able when reversing it... .. yup that would be case in my set code as well.. base/cover duplicates are not added to existing sets.

It seems to me that you completely ignore such considerations.

more often, quickly respond with endless editing posts as my time to do what i like to do is constrained.
often I forget that others don't have the same history working with the programs internally as i do, it is however not intentional
thank you for reminding me to be more cautious/astute

{probably should go back to posting how i used to, write a document it re read,edit cross check everything verify everything with others then commit to the post: its helped in the past making me more easy to understand/convey my point}

i do apologize for the inconveniences i have caused in my posts but you have enabled me to do stuff in my own solver thanks to different insights you have presented, and that i appreciate.

[SpAce]

This is a bit off topic?

Not at all!

3 strong links a,b and c ==> r1c6<>5
because r1c6 is strongly linked to r3c4 (d) then we have in theory 2 simultaneous and cannibalistic Fishes here (with r3c3<>5)
Because the share 2 of the 3 strong links, is this is what you refer to as Siamese?

First of all, we have a Siamese fish when the same base sets are combined with multiple groups of cover sets to produce different eliminations. Skyscraper is a classic example: to get the eliminations in both boxes you have to use two different cover groups.

Here we seem to have a bit different situation. You're right that those eliminations can be seen through several Siamese fishes (just turn on that option in Hodoku and see what it produces), but they're pretty complicated. I don't think it's a great idea here as we have simpler options. The most practical one is to just eliminate one or the other candidate for the same end result. I'd opt for a simple X-Chain, but in this context either of these 3x4 Mutants would work:

(5)B178\r19c36 => -5 r1c6
(5)B278\r39c36 => -5 r3c3

Note that the base sets are different, which means that there's no direct option to combine them into a Siamese 3-fish. They can be combined into a cannibalistic Siamese 4-fish, though. Here's how Hodoku would see it:

Siamese Finned Mutant Jellyfish: 5 b1278 r19c36/r39c36 fr3c4 fr1c2 => r1c6,r3c3<>5

The corresponding Siamese Mutant 4x5-fish (I think):

(5)B1278\r9c36[r1b2|r3b1] => -5 r1c6,r3c3

(The fish is Rank 1 (5-4) so cannibalistic eliminations require three covers: r1c6b2 (for -5r1c6) and r3c3b1 (for -5r3c3). Having the same sets (b1/b2) as both bases and covers indicates that something is over-complicated, as cannibalistic eliminations often are. Thus I'd rather use one or the other simpler fish.)

[tarek]

That is clear now … So it is not some of the base sets are shared but all the base sets must be shared

Thanks

tarek

[SpAce]

StrmCkr, thanks for the explanations. Just quickly about this for now:

obis math from

R1133 / c3b133 => r2456789c3<>7, r2c12789<>7
R11233/C3R2B13 => r2456789c3<>7, r2c12789<>7
B2 R123/ C3 R2 B3=> r2456789c3<>7, r2c12789<>7
B1223 / C3 R2 => r2456789c3<>7, r2c12789<>7
B12/C3 R2 => r2456789c3<>7, r2c12789<>7

I can't follow that math after the second line. I can see that you added r2 to both sides, which is fine (that's how I started too), but what happens next is a mystery to me. [Edit. Actually, I just noticed that the right side of the second line is missing a b3, so I don't get even that.] Furthermore, your end result B12\r2c3 is not equivalent to R1133\c3b133. Specifically, it would not eliminate -7r2c2 which is a base candidate in your result fish. Here's my math:

Code: Select all

r1133\c3b133      +r2
r11233\r2c3b133   r123 -> b123
r13b123\r2c3b133  -b13
r13b2\r2c3b3


That result is equivalent to the start fish, and the operations to get there are very simple and easy to follow if you know Obi's arithmetic rules:

1) add/remove same sets to/from both sides
2) convert full chutes of lines/boxes into each other

That's it, as far as I know. I have no idea what you're doing, but it doesn't seem to work correctly.

Added. I think the closest thing to your result fish that gets all the eliminations as per normal Obi-fish rules is this:

B122\r22c3 => -r2c279,r78c3 (cannibalistic: -r2c2)

It also transforms into the same Mutant 3-fish:

Code: Select all

b122\r22c3        +b3
b1223\r22c3b3      b123 -> r123
r123b2\r22c3b3    -r2
r13b2\r2c3b3

Thus, whatever you're doing can't be called "obis math" because you're obviously using different rules, and apparently your result fish should be interpreted using different rules too to get all the eliminations. None of it is transparent or even indicated in your notation.

[SpAce]

That is clear now … So it is not some of the base sets are shared but all the base sets must be shared

Exactly. Based on this it seems that some people used to restrict it to situations where only a single cover set would differ, but I think it's an unnecessary constraint:

Siamese fish: Two N*N fish that share N*(N-1) sectors. They use a different N-th Cover sector to complete the fish pattern and perform different eliminations.

I guess in most cases that rule is followed anyway when the fish is viewed as NxN+fins. When the fin sectors are added for an NxM fish, then at least two cover sectors are usually (always?) different.

[StrmCkr]

Really don't know wtf happened on copy paste from sticky notes...
A bunch of stuff garbled...
Rewrote it again.... I originally did what you listed...

[SpAce]

Really don't know wtf happened on copy paste from sticky notes...
A bunch of stuff garbled...
Rewrote it again.... I originally did what you listed...

I'll check it out. You'd posted this while I was editing my post (see those changes as well).

Added: Seems that we can agree on that result (B122\r22c3), as we posted it almost the same time

[StrmCkr]

B2\r2c3

Compared to
b122/r22c3 (remove duplicates)

B12/r2c3.... And we find the invisible sector readded b1.

Which means obis arthimatic can't verify conversion on setwise reduction notation with out knowing the duplicates..

[SpAce]

Which means obis arthimatic can't verify conversion on setwise reduction notation with out knowing the duplicates..

Yeah, the duplicates are kind of important in Obi's arithmetic.

That said, I must get back to your original claim... because I think we were both partly right and wrong.

and reduces to R13/C3B13 => r2456789c3<>7, r2c12789<>7 and still holds the rank zero as displayed in xsudoku

I don't see how it reduces to that. Not with Obi's rules, nor with documented XSudo rules either.

It's definitely true that Obi's rules (alone) don't allow such reductions, but I think I now understand why that works with XSudo and why it reports all of those as rank 0 eliminations. In fact, I'm kind of embarrassed that I didn't see it from the beginning, but I guess it's because I've only used XSudo's set logic with multi-digit fishes (without ever using the program). Somehow I didn't think to apply the same exact rules with our single-digit fish.

I still think that the correct way to see that fish in XSudo terms is that it has an overall Rank 1, as I said from the beginning. As such it wouldn't normally eliminate anything here, as I also said, because none of the potential eliminations are covered by two or more overlapping sets. However, the base candidates r13c3 are link triplets (both covered by two sets, c3 and b1), which lowers the rank to 0 effectively everywhere in this particular pattern. That's why all three cover sets have rank 0 (i.e. they're guaranteed to hold a base candidate) and the eliminations are valid. Or so I think.

So, assuming that explanation is correct, we were both right and wrong. I was right about the fish being Rank 1, but you were right about the rank 0 eliminations. Your biggest failure was that you couldn't clearly explain why they were rank 0 and claiming that the fish itself was Rank 0 (even though it effectively is). (I think XSudo is equally wrong if it presents a 2x3 fish as a Rank 0 fish without further explanations. In fact, I'd be tempted to suspect that it only reports the eliminations as Rank 0, not the fish itself, but since I don't have the program I can't verify that.) I think that's the whole problem with your fish approach. If you're using Allan Barker's logic, or something similar to it, you should be able to explain it much better and also notate it somehow with your fishes. It's very confusing if you present them as if they were normal fishes governed by the normal rules (i.e. UFG or Obi-Fish). They're not.

It's not enough to say they're NxN+k or NxM and assume that people can draw the right conclusions, because at least to me that would imply Obi-Fish rules which don't really apply with yours. It's not enough to say that they combine Allan's and Obi's logic, because that doesn't really mean anything without details. The link you provided above is not adequate documentation of your fish rules at all. I'd seen it before and promptly ignored it, as I did now, because it's not presented as a human-oriented technique (I can read code just fine but in this context I don't want to). So, if you want anyone (or at least me) to really understand -- or to even want to understand -- your fishes, you have to provide better and more accessible documentation, i.e. something that is not presented as code and hidden on one of the 44 pages of the UFG.

Allan's set logic is powerful but very complicated stuff when triplets and different rank regions get in the picture. Then it's not enough to just list the sets and state the eliminations, because it's not at all obvious why they happen. You must also indicate the triplets (or whatever counterpart you're using in your program) and their implications, which is often not exactly easy. That's why the UFG and even Obi-Fishes are much more intuitive for human-consumption. I would stick to them when presenting single-digit fishes because they're much more understandable to most people. Allan's set logic is more suitable for multi-digit fishes, imho, because they're more complicated anyway and there's no real alternative either.
--
Added. Thanks to this discussion, I'm now thinking that Obi's approach could actually simplify Allan's multi-digit logic too... see an example below.

My solution for today's puzzle:

Code: Select all

.------------------.---------------.-----------------------.
| 5    89    3     | 79   1    679 |    4      289   2689  |
| 2    1     7     | 4    8    69  |    5      3     69    |
| 49  c489   6     | 2    5    3   |   c89     7     1     |
:------------------+---------------+-----------------------:
| 37   2    a4[89] | 1    3-9  57  | ad[8(9)]  6     458-9 |
| 1   b49    5     | 6    2    8   |    3      49    7     |
| 37   6     89    | 57   39   4   |    2      1     589   |
:------------------+---------------+-----------------------:
| 8    7     49    | 359  6    2   |    1      459   349   |
| 49   5     2     | 389  7    1   |    6      489   3489  |
| 6    3     1     | 589  4    59  |    7      2589  289   |
'------------------'---------------'-----------------------'

(98=4)r4c73 - r5c2 = (48-9)r3c27 = (9)r4c7 => -9 r4c59; stte

as a 5x5 matrix: Show

Code: Select all

  9r4*   3n7   3n2   4b4   8r4  |
--------------------------------+------
 9r4c7  9r3c7                   | 9C7 *
        8r3c7 8r3c2             | 8R3
              4r3c2 4r5c2       | 4C2
 9r4c3              4r4c3 8r4c3 | 4N3
 9r4c7                    8r4c7 | 4N7 *
--------------------------------+------
-9r4c59                         |

Written using Allan's normal set logic (as I understand it, based on the documentation alone):

Alien 5x5-Fish (Rank 1; base triplet 9r4c7): {8R3 4C2 9C7 4N37} \ {89r4 4b4 3n27} => -9 r4c59 (Rank 0 in 9r4)

That's pretty hard to understand, imho, because it's a 5x5 fish yet the overall Rank is not 0 but 1 due to the base triplet 9r4c7 (which belongs to base sets 9C7 and 4N7). For the same reason the eliminations are hard to see, because we're required to realize that the same base triplet lowers the Rank of its cover 9r4 so we actually have a local Rank 0 there. In other words, it's kind of like an endo-fin in UFG terms. Very complicated. So... why not use Obi's style to get rid of both problems:

Alien 5x6-Fish (Rank 1): {8R3 4C2 9C7 4N37} \ {899r4 4b4 3n27} => -9 r4c59 (Rank 1)

With the duplicated cover 9r4 the overall Rank 1 is now easily calculated (6-5). No need for any local rank adjustment either, because the eliminations are explicitly covered twice as they should in a Rank 1 fish. Much simpler, I think!

[StrmCkr]

why not use Obi's style to get rid of both problems:

because it is obis math setup in a setwise environment.
The issues with sets, as I've said several times is set a added to set b cannot change the element count for same objects.

Because of that issue, my version also loses the ability to use Obi's arithmetic for fish conversion in some odd cases with extra coversets added after equations are balanced (so either I disable it in full or solve the issues)

So yes I failed at explaining it, knew it was a rank 0 by my code math from the noted coding limits above.
and could verify the formation in another program but it as dosent list reasons either.

So back to my code and tinker this is the results.

My code was only doing this in nxn cases as i disabled it for the +1/2 K values as it caused issues I couldn't sort out

Until this very topic;

the issues as it turns out is the counting duplicated cover in terms of rxc, rxb, cxb intersection space within those extra covers defined spaces which only applies in higher K values.

now i have a system in place that marks the overlapping duplicated covers cells for each ajorning sector.

When my fish code checks for extra sectors to add after the initial base x cover = base is balanced.

In essence it now shows me exactly where the fish has multiplicative coverage on specific cells (ie which base is duplicated)

Which in turn gave me a way of solving the +1\2 K value scenarios as well as note extra bases.

Code: Select all

 
    .---------------------------------.---------------------------------.---------------------------------.
    | 12345689   12345689   123456789 | 12345689   12345689   12345689  | 123456789  12345689   12345689  |
    | 123456789  123456789  12345689  | 123456789  123456789  123456789 | 123456789  123456789  123456789 |
    | 12345689   12345689   123456789 | 12345689   12345689   12345689  | 12345689   12345689   123456789 |
    :---------------------------------+---------------------------------+---------------------------------:
    | 123456789  123456789  123456789 | 123456789  123456789  123456789 | 123456789  123456789  123456789 |
    | 123456789  123456789  123456789 | 123456789  123456789  123456789 | 123456789  123456789  123456789 |
    | 123456789  123456789  123456789 | 123456789  123456789  123456789 | 123456789  123456789  123456789 |
    :---------------------------------+---------------------------------+---------------------------------:
    | 123456789  123456789  123456789 | 123456789  123456789  123456789 | 123456789  123456789  123456789 |
    | 123456789  123456789  123456789 | 123456789  123456789  123456789 | 123456789  123456789  123456789 |
    | 123456789  123456789  123456789 | 123456789  123456789  123456789 | 123456789  123456789  123456789 |
    '---------------------------------'---------------------------------'---------------------------------'


R3B2 / R2B13 => R2c123789 <> 7 exchangeable covers C39 with b13 generates theses subsets with reduced eliminations when considering them as individuals.
r3b2/r2c9b3 => r2c3789 <> 7
r3B2/r2c9b1 => r2c1239 <> 7
r2b2/r2c39 => r2c39 <> 7

the 2 extra covers can be included in all the fish as redundant covers,
R3B2/R2C39B13 => R2c123789 <> 7

(in reduced base notations from my solver code)
- still have to re add the extra bases to balance for obi arthimatic
its messy and i doubt anyone would do this asides from my solver

But the fact these now work is good news for me.

[creint]

You could also call this ALS with chain. (Single ALS Logic, Reduced)

From a programmer's perspective, how do you program this (efficiently)?
Combining all possible truths and enumerating all possible ways to link the truths, trying to find eliminations?
Of course I want to create generic approach for my program.
XSudo is crashing on pencilmark grids, and its very slow in finding all rank 0's.
Full rank 0 should be easier to find because there are no overlapping truths.

[StrmCkr]

Written using Allan's normal set logic (as I understand it, based on the documentation alone):

Alien 5x5-Fish (Rank 1; base triplet 9r4c7): {8R3 4C2 9C7 4N37} \ {89r4 4b4 3n27} => -9 r4c59 (Rank 0 in 9r4)

That's pretty hard to understand, imho, because it's a 5x5 fish yet the overall Rank is not 0 but 1 due to the base triplet 9r4c7 (which belongs to base sets 9C7 and 4N7). For the same reason the eliminations are hard to see, because we're required to realize that the same base triplet lowers the Rank of its cover 9r4 so we actually have a local Rank 0 there. In other words, it's kind of like an endo-fin in UFG terms. Very complicated. So... why not use Obi's style to get rid of both problems:

Alien 5x6-Fish (Rank 1): {8R3 4C2 9C7 4N37} \ {899r4 4b4 3n27} => -9 r4c59 (Rank 1)

With the duplicated cover 9r4 the overall Rank 1 is now easily calculated (6-5). No need for any local rank adjustment either, because the eliminations are explicitly covered twice as they should in a Rank 1 fish. Much simpler, I think!

you just showed it works for multi-fish so that's great.
that's the direction my fish code was heading towards for multi-digit fish.
i could do the easy n digits in n sectors easy enough but the same errors i just resolved here applied N fold in multi-fish for the almost patterns { k variations}.