The New Sudoku Players' Forum

[SpAce]

I originally asked this question here but it's probably not going to get answered there. So here goes. What happened was that I came up with a net to eliminate a certain candidate (yes, there were plenty of easier eliminations available but that's not relevant), and then checked how Hodoku would have eliminated the same candidate. It also used a net, but I can't understand what it really did. The puzzle is this, and the target is (5)r8c1:

Code: Select all

.-------------------.----------.---------------.
|  6     2589  589  | 7  1  29 |fa[38] 358  4  |
|  4     289   3    | 5  6  29 |   1   7   g89 |
|  159   7     159  | 3  4  8  |   26  26   59 |
:-------------------+----------+---------------:
|  3     689  d6789 | 2  5  4  |  e78  89   1  |
|  18    148   2    | 6  9  7  |   5   48   3  |
|  579   459   579  | 8  3  1  |   27  249  6  |
:-------------------+----------+---------------:
|i(5)78  3    c5678 | 9  2  56 |   4   1   h58 |
| (8)-5  568   4    | 1  7  3  |   9   568  2  |
|  2     19    19   | 4  8  56 |  b36  356  7  |
'-------------------'----------'---------------'

Hodoku offered the following net solution:

Forcing Net Verity => r8c1<>5

r1c7=3 r9c7<>3 r7c3=7 (r7c1<>7) r4c3<>7 r4c7=7 r4c7<>8 r1c7=8 r2c9<>8 r7c9=8 r7c1<>8 r7c1=5 r8c1<>5

r1c7=8 r2c9<>8 (r2c2=8 r8c2<>8) r7c9=8 r8c8<>8 r8c1=8 r8c1<>5

My translation into a Eureka-like Kraken Cell (38)r1c7:

(3)r1c7 - r9c7 =???= (7*)r7c3 - r4c3 = (7-8)r4c7 = r1c7 - r2c9 = r7c9 - (8|*7=5)r7c1
||
(8)r1c7 - r2c9 = r2c2&r7c9 - r8c8,r7c13 = (8)r8c1

=> -5 r8c1

The path with the 8 is simple enough (not marked), but not so with the 3 (marked). How does the second link (b=c) work??? What am I missing? Here's the image for that path Hodoku produced:

Screen Shot 2018-09-14 at 0.07.04.png (89.24 KiB) Viewed 1053 times

I really can't see how (3)r9c7 = (7)r7c3. I can produce a path that does that, but it's not trivial:

Code: Select all

(3)r1c7 - (3=6)r9c7 - r9c6 = r7c6 - r7c3 = (6-7)r4c3
             |                                ||
            (6=2)r3c7 - (2=7)r6c7 -----------(7)r6c3
                                              ||
                                             (7)r7c3 ...

Furthermore, I don't really see why it wants to use the (7)r7c3 anyway. There's a simpler path:

(8)r1c7 - r2c9 = r2c2&r7c9 - r8c8,r7c13 = (8)r8c1
||
(3)r1c7 - (3=6)r9c7 - r9c6 = r7c6 - r7c3 = (6-7)r4c3 = (7-8)r4c7 = (8)r1c7 - ... = (8)r8c1

=> -5 r8c1

(Of course that makes little practical sense, because the beginning of the 3-branch already proves -3 r1c7 (stte) but that's not relevant -- our mission was to take out 5r8c1.)

So, can someone explain to me how Hodoku's net was actually supposed to be interpreted? Was it missing parts of the path, or did I miss something? Thanks in advance for any insights!

[pjb]

I am similarly confused by this output. A rather heroic approach when there are so much simpler moves. For example, a double ALS at r1369c3 and r1369c7, X-Z values 8, 7 leaves a couple of simple moves to solve.

Phil

[SpAce]

I am similarly confused by this output.

Thanks for the emotional support, Phil! Good to know I'm not the only one.

A rather heroic approach when there are so much simpler moves.

Well, my first UR solution was probably the simplest possible so I wanted something different But you're right, of course. There are quite a few simple stte solutions for this puzzle that don't require even any ALS nodes, like your AIC and the one extracted from the net above. Sometimes simplicity is not a primary objective, however.

For example, a double ALS at r1369c3 and r1369c7, X-Z values 8, 7 leaves a couple of simple moves to solve.

Double ALSs are fun to find (like all closed loops), but I don't think this one is very effective. It does give 5 eliminations but only one direct single, and one still needs non-basic moves after it. I'm not good at spotting large ALSs anyway, so I wouldn't necessarily count it as a simple move. ALS moves are very short and elegant once you spot them, but spotting them manually is a different matter (at least for me).

[Kozo Kataya]

Would like to present another idea is re digit 8 only ,no-chains.
Because of r2c29 and r7c9 (marked *),
r14c8 and r48c2 (marked -) must be deleted, then stte.

Code: Select all

|    8  8|         |  8 -8   |     
|   *8   |         |       *8|   
|        |        8|         |     
|--------+---------+---------|   
|   -8  8|         |  8 -8   |     
| 8  8   |         |     8   |     
|        | 8       |         |     
|--------+---------+---------|   
| 8     8|         |       *8|   
| 8 -8   |         |     8   |
|        |     8   |         |    


Regards

[SpAce]

Would like to present another idea is re digit 8 only ,no-chains.

Thanks for another option!

Because of r2c29 and r7c9 (marked *),
r14c8 and r48c2 (marked -) must be deleted, then stte.

But what does "because of" actually mean? How would you describe and document your move (besides something like templates/POM which obviously works but is not very human-friendly)? I can get the eliminations easily with GEM coloring, but I wouldn't call that a move (maps to multiple chains/nets). Is there a single move -- an exotic fish, for example -- that could do it? The best Hodoku can find is this (I think):

Finned Mutant Jellyfish: 8 r258c7 c128b3 fr4c7 => r4c28<>8

It only gets 2/4 eliminations but they're the essential ones for stte.

This fish gets 3/4, but not the right ones:

Finned Mutant Squirmbag: 8 r28c37b9 r14c29b7 efr8c8 => r14c8,r8c2<>8

I can't find a move that would get all 4/4, except via templates.

[Kozo Kataya]

Hi SpAce ,

But what does "because of" actually mean? How would you describe and document your move

An idea is so simple.
Because of r2c29 and r7c9, next steps are r2c9<>8 or r2c9=8,
in both cases, r14c8 and r48c2 are eliminated.

Code: Select all

  single digit 8s                    when r2c9<>8                       when r2c9=8
|    8  8|         |  8 -8   |     |    -  -|         |  8  -   |     |    8  8|         |  -  -   |
|   *8   |         |       *8|     |   *8   |         |        *|     |    *   |         |       *8|
|        |        8|         |     |        |        8|         |     |        |        8|         |         
|--------+---------+---------|     |--------+---------+---------|     |--------+---------+---------|
|   -8  8|         |  8 -8   |     |    -  8|         |  -  -   |     |    -  -|         |  8  -   |
| 8  8   |         |     8   |     | -  -   |         |     8   |     | 8  8   |         |     -   |
|        | 8       |         |     |        | 8       |         |     |        | 8       |         |
|--------+---------+---------|     |--------+---------+---------|     |--------+---------+---------|
| 8     8|         |       *8|     | -     -|         |       *8|     | 8     8|         |        *|
| 8 -8   |         |     8   |     | 8  -   |         |         |     | -  -   |         |     8   |
|        |     8   |         |     |        |     8   |         |     |        |     8   |         |


Regards

[SpAce]

An idea is so simple.
Because of r2c29 and r7c9, next steps are r2c9<>8 or r2c9=8,
in both cases, r14c8 and r48c2 are eliminated.

Thanks, Kozo. That much is clear, of course. My question was: how would you communicate that as a single move (as per the standards of the Puzzles section of this forum)? I can't see any easy options. I can write a single forcing (or AI) net that can be used to deduce all those eliminations but it requires looking at multiple strongly-linked pairings within it. I think that would count as multiple moves. For example, if I translate your explanation directly into a Kraken Candidate using the on/off states of (8)r2c9 we get something like:

(+8)r2c9 - r7c9 = r8c8 - r45c8 = (8)r4c7
||
(-8)r2c9 = r2c2*&r7c9 - r8c2,r7c13 = r8c1 - r5c1,*r45c2 = r4c3 - r4c78 = (8)r5c8

Normally we would only use the endpoints to deduce (8)r4c7 == (8)r5c8 => -8 r4c8. However, we can of course use other strongly-linked pairings within the net as well to get:

-> (8)r8c8 == (8)r5c8 => -8 r14c8
-> (8)r4c7 == (8)r4c3 => -8 r4c28
-> (8)r8c8 == (8)r8c1 => -8 r8c2

==> -8 r48c2, r14c8

That would work, but isn't that three separate deductions using three subnets? Now, I think it could be written as some kind of an AI-net-loop which could get all those eliminations using loop-rules (all weak links in non-branching parts can be used for eliminations), but it would get complicated and error-prone. Another possibility would be a matrix of some kind, but I can't write those.

So, all I'm saying is that while your logic is perfectly valid, it's not easily translated into a single move (acceptable as such for the forum puzzle challenges). Or so it seems to me, but you're very welcome to prove me wrong.

Added: If I stretch the previous kraken into an AI-net-loop, I think I can get 3/4 of those eliminations using the loop weak-link eliminations:

(8)r4c7=r45c8-r8c8=r7c9*-r2c9=r2c2^-(r8c2,*r7c13)=r8c1-(r5c1,^r45c2)=r4c3-r4c78=(8)r5c8-loop

r45c8-r8c8 -> -8 r1c8
r4c3-r4c78 -> -8 r4c2
r5c8-r4c7 -> -8 r4c8

But, again, loops are quite error-prone when using nets. It's very ugly too. (And r8c2 is not covered.)

[StrmCkr]

I can't find a move that would get all 4/4, except via templates.

Code: Select all

+--------------------+----------+-------------------+
| 6    2589   59(8)  | 7  1  29 | 3(8)  35-8   4    |
| 4    29(8)  3      | 5  6  29 | 1     7      9(8) |
| 159  7      159    | 3  4  8  | 26    26     59   |
+--------------------+----------+-------------------+
| 3    69-8   679(8) | 2  5  4  | 7(8)  9-8    1    |
| 18   148    2      | 6  9  7  | 5     48     3    |
| 579  459    579    | 8  3  1  | 27    249    6    |
+--------------------+----------+-------------------+
| 578  3      567(8) | 9  2  56 | 4     1      5(8) |
| 58   56-8   4      | 1  7  3  | 9     56(8)  2    |
| 2    19     19     | 4  8  56 | 36    356    7    |
+--------------------+----------+-------------------+


whale- R2C3779B9 / R1478C2B36
=>> 4 eliminations.

part of the downfall of nxn fish is that they do not find all the eliminations for the set if it has "endo" or "exo" cells and need multiple variations to tag all of them.
{they also do not list "remora" eliminations if they are applicable.{internal smaller fish eliminations }

compared to nxn+K fish which finds everything applicable. {almost everything.... there is some templates that have no known fish solutions to date}

{hodoku uses NxN rules from the u.f.g}

edit: was using xsudo for the fish diagram....and it reduces the "extra" base cover.... added the missing stuff so it hopefully makes sense..

[SpAce]

starfish{squirmbag} R2C379B9 / R1478C2B3
=>> 4 eliminations.

Hi StrmCkr! I think you're probably right that an nxn+k fish might work. However, I don't quite understand how yours does. My understanding of those kinds of fishes is even worse than normal ones, but it seems to me that your fish breaks Obi-Wahn's construction rule, and even if it didn't, it wouldn't eliminate all of our targets. Then again, it's very possible that I've completely misunderstood something.

It says here:

Construction rule: We have a Fish pattern if we can construct two sets of sectors, a base set and a cover set, in such a way that every candidate of a given digit belongs to at least as many cover sectors as it belongs to base sectors.

If our fish is r2c379b9 / r1478c2b3, I think that rule is broken with r27c9. Those cells belong to two base sectors but are only covered once, correct?

Number of fin sectors = Number of cover sectors - Number of base sectors

With this convention the second rule simply is:

Exclusion rule: Any candidate of the digit in question, whose individual excess number of cover sectors is greater than the number of fin sectors in the pattern, can be eliminated.

Even if our fish were valid (by rule 1), I don't see how we'd get the right eliminations by rule 2. If I've understood correctly, our number of fin sectors is 1, so we need two covers to eliminate anything. I came up with these counts (covers - bases; cells with fish digits in brackets):

Code: Select all

 +1  (+2) (0) | +1 +1 +1 | (+1) (+2)  +1
 -1   (0) -2  | -1 -1 -1 |  -1    0  (-1)
  0   +1  -1  |  0  0  0 |   0   +1    0
--------------+----------+---------------
 +1  (+2) (0) | +1 +1 +1 |  (0) (+1)   0
 (0) (+1) -1  |  0  0  0 |  +1   (0)  +1
  0   +1  -1  |  0  0  0 |  -1    0   -1
--------------+----------+---------------
(+1)  +2  (0) | +1 +1 +1 |  -1    0  (-1)
(+1) (+2)  0  | +1 +1 +1 |  -1   (0)  -1
  0   +1  -1  |  0  0  0 |  -2   -1   -2

It looks like 4 eliminations as expected, but instead of r4c8 we'd get r1c2. A bigger problem is those negative values in r27c9.

Have I misunderstood something? (It's very much possible. I have never tried working with nxn+k fishes before.)

[SpAce]

[/code] whale- R2C3779B9 / R1478C2B36

edit: was using xsudo for the fish diagram....and it reduces the "extra" base cover.... added the missing stuff so it hopefully makes sense..

Thanks! It makes more sense, but r7c9 still has two bases (c9,b9) and only one cover (r7), hence breaking Obi-Wahn's construction rule. It also looks like r1c2 would get eliminated (+2 covers) in addition to the four known targets.

Code: Select all

  0 +2 +0 | 0  0  0 |+0 +2  0
  0 +0  0 | 0  0  0 | 0  0 +1
  0  0  0 | 0  0  0 | 0  0  0
----------+---------+----------
  0 +2 +0 | 0  0  0 |+0 +2  0
 +0 +1  0 | 0  0  0 | 0 +1  0
  0  0  0 | 0  0  0 | 0  0  0
----------+---------+----------
 +1  0 +0 | 0  0  0 | 0  0 -1
 +1 +2  0 | 0  0  0 | 0 +0  0
  0  0  0 | 0  0  0 | 0  0  0

[StrmCkr]

the swordfish + finned X-wing + Empty Rectangle
=> the 4 eliminations.

id have to go dig through my code to get my fish finder to show the larger move any fish above size 5 unfortunately takes 4 hours to cycle through... {as it does all combinations of
choose(1-7 ) from 27 sectors x choose ((1-7)+2) out of 20 sectors }

pretty painful compared to template focused searching hodoku implores....

but xsudoku does show the larger fish works for all 4 eliminations.

[SpAce]

Thanks for the effort, StrmCkr! I'm having trouble understanding this nxn+k fish stuff. Normal finned fishes seem easy to express in that format, but endo-fins seem more complicated. I don't really understand the arithmetic rules either. Could we perhaps construct a larger fish out of smaller ones that together produce those eliminations? We have these, for example:

Sashimi X-Wing: 8 r27 c29 fr7c1 fr7c3 => r8c2<>8
Finned Franken X-Wing: 8 c7b1 r14 fr2c2 => r4c2<>8
Finned Franken Swordfish: 8 c37b9 r147 fr8c8 => r14c8<>8

I chose those because they don't have any endo-fins and are easy to convert into nxn+k. Then I tried naively adding them up, but that didn't produce anything useful. Adding more covers might help, but it increments the k, unless we also add bases, which leads to having to add more covers, and so on. I can get some eliminations but not all.

I would have wanted to use this as a starting point (because it already gets 3/4) but I'm not sure how to handle that endo-fin correctly:

Finned Mutant Squirmbag: 8 r28c37b9 r14c29b7 efr8c8 => r14c8,r8c2<>8

[blue]

This is (mostly) just for laughs, but ...

Code: Select all

Remotely Finned (Franken) X-Wing: r2b9\c28 + fr2c9,fr8c9
Potential eliminations include: r14c8,r48c2

Remote Links:

  r2c9 - r7c9 = r8c8 - r14c8,r8c2
  r2c9 - r1c7 = r4c7 - r4c2

  r7c9 - r7c3 = (X-Wing c37\r14) - r1c8,r4c28
  r7c9 - r2c9 = r2c2 - r8c2

[SpAce]

Thanks, blue! That's an interesting way to see it. Too bad the fish doesn't really help us, because we could just as well use those fin cells directly (as they're natively strongly linked) and forget about the fish body (because it can never be true). As far as I can see, it's essentially the same as the earlier net solution (but with a neat twist using the almost-X-Wing!).