The New Sudoku Players' Forum

[ArkieTech]

Code: Select all

 *-----------*
 |...|...|9..|
 |.3.|.92|.4.|
 |946|1..|5..|
 |---+---+---|
 |..1|3..|.7.|
 |...|.2.|...|
 |.7.|..5|6..|
 |---+---+---|
 |..9|..6|831|
 |.1.|97.|.6.|
 |..3|...|...|
 *-----------*

......9...3..92.4.9461..5....13...7.....2.....7...56....9..6831.1.97..6...3......


Play/Print this puzzle online

[SpAce]

Code: Select all

.-------------------.--------------------------.----------------.
|  1      25   257  | h(5)467  h(3)546   47    | 9    8    367  |
|  58     3    578  | h(5)67     9       2     | 1    4    67   |
|  9      4    6    |   1      h(8)3    g78    | 5    2    37   |
:-------------------+--------------------------+----------------:
|  2456   89   1    |   3        468    g489   | 24   7    2458 |
|  456    89   45   |   4678     2      g14789 | 3    15   458  |
|  3      7    24   |   48      e148     5     | 6   e19   2489 |
:-------------------+--------------------------+----------------:
|  7     b25   9    |  b245      45      6     | 8    3    1    |
| c2458   1   c2458 |   9        7       3     | 24   6   d245  |
|  245    6    3    | a[2]-58   f158  fh(8)1   | 7   d59   2459 |
'-------------------'--------------------------'----------------'

(2)r9c4 = (2,5)r7c42 - r8c13 = (59)b9p68 - (91)r6c85 = (1,8)r9c56 - r345c6 = (835)b2p8214,(8)r9c6 => -58 r9c4; stte

Hope to see something nicer.

[Cenoman]

Code: Select all

 +---------------------+------------------------+-------------------+
 |  1      25   257    | b4567  a3456  b47      |  9    8    367    |
 |  58     3    578    | b567    9      2       |  1    4    67     |
 |  9      4    6      |  1      38    c78      |  5    2    37     |
 +---------------------+------------------------+-------------------+
 | D2456   89   1      |  3      468    489     |  24   7    2458   |
 |  456    89   45     |  4678   2      14789   |  3    15   458    |
 |  3      7   E24     | E48    E148    5       |  6    19   2489   |
 +---------------------+------------------------+-------------------+
 |  7     B25   9      |  245   A45     6       |  8    3    1      |
 | C2458   1    2458   |  9      7      3       |  24   6    245    |
 | C245    6    3      |  258   z58-1  c18      |  7    59   2459   |
 +---------------------+------------------------+-------------------+

Kraken column (5)r179c5
(5)r1c5 - (5=467)b2p134 - (7=81)r39c6
(5)r7c5 - (5=2)r7c2 - r89c1 = r4c1 - (2=481)r6c345
(5)r9c5
=> -1 r9c5; ste

[Mauriès Robert]

Hi
Resolution with TDP from 4 of c4.
1) P(4r15c4) = {4r15c4, 4r7c5, 8r5c4, 1r6c5, 9r6c8, ...} ,
2) P(4r7c4) = {4r7c4, 2r7c2, 2r1c3, 4r6c3, 8r6c4, 1r6c4, 9r6c8, ...} ,
3) P(r4r6c4).P(8r3c56) = {4r6c4, 4r7c5, 4r1c6, (8r3c5, 1r6c5), (8r3c6, 7r5c6, 1r6c5), 9r6c8, ...} , track with extension (see diagram below) ,
=> r6c8=9, stte.

Code: Select all

                                  -> 8r3c5 - - - -
                                 |                 |
4r6c4 -> 4r7c5 -> 4r1c6 -> 8r3c56                   -> 1r5c6 -> 9r6c8
                                 |                 |
                                  -> 8r3c6 -> 7r5c6


The fastest resolution with TDP is the following P(1r6c8) leads to contradiction => r6c8=9, stte.
But I like Cenoman's resolution, because Kraken is TDP !
Robert

[StrmCkr]

Code: Select all

+-------------------+---------------------+----------------+
| 1     5(2)  57(2) | 4567  3456    47    | 9   8     367  |
| 58    3     578   | 567   9       2     | 1   4     67   |
| 9     4     6     | 1     3(8)    7(8)  | 5   2     37   |
+-------------------+---------------------+----------------+
| 2456  89    1     | 3     468     489   | 24  7     2458 |
| 456   89    (45)  | 4678  2       14789 | 3   (15)  458  |
| 3     7     (24)  | 48    -48(1)  5     | 6   (19)  2489 |
+-------------------+---------------------+----------------+
| 7     (25)  9     | 245   (45)    6     | 8   3     1    |
| 2458  1     248-5 | 9     7       3     | 24  6     245  |
| 24-5  6     3     | 258   8-5(1)  (18)  | 7   (59)  2459 |
+-------------------+---------------------+----------------+

over kill
singles to the end

[Mauriès Robert]

Hi StrmCkr,
You wrote:

over kill
singles to the end

I don't understand, can you elaborate?
Thank you.
Robert

[StrmCkr]

Sure

3 moves combined into one.

Als w wing
Hybrid wing
L2 wing

Extra 2 cells added to make them loop (r5c38)

Only 2 techniqurs are needed to reduce the puzzel to basic
All three for singles so it is overkill.

[Cenoman]

But I like Cenoman's resolution, because Kraken is TDP !

Thanks, I take that as a compliment, though I can't understand why and how "Kraken is TDP"...
I miss time for the brain investment in learning TDP.

Regards.

[StrmCkr]

Its not Carmen.
he seems to think we are placing digits and following multi forked paths which is tdp

[SpAce]

Kraken is TDP !

Not any more or less than AICs. AICs are two-way krakens written on one line, and three-or-more-way krakens can be seen as multi-headed AICs. Both can be converted into each other at will, though obviously an AIC gets more complicated if it has to embed kraken branching (multiple ways to do that).

If such branching is required, krakens are usually the more readable variant and also easier to write. I usually prefer the additional challenge of writing complex AICs, though I freely acknowledge it doesn't necessary improve readability. I have to admit that I rarely even read kraken solutions -- not because they're bad or unreadable (au contraire) but because there's usually nothing surprising or questionable. I often simply trust that they're correct and move on.

Complex AICs have a lot more room for error, which makes them more interesting to write and to read for me. With lots of branching krakens are of course the obvious or the only choice, like here or here (the latter was obviously a joke).

My solution for this puzzle could be written as a two-way kraken too, and it's not a bad idea if the chain is very long. In this case, if I chose to go that route I'd rather write it as a kraken-like net (due to the ANDed end point) with explicit details:

Code: Select all

(1)r6c5 - (1=9)r6c8 - (9=5)r9c8 - r8c9 = r8c13 - (5=2)r7c2 - r7c4 = (2)r9c4
||
||                            (8-3)r3c5 = (3-5)r1c5 = (5)r12c4
||                           //
(1)r9c5 - (1=8)r9c6 - r345c6
                             \\
                              (8)r9c6

=> -58 r9c4; stte


The original AIC:

Code: Select all

(2)r9c4 = (2,5)r7c42 - r8c13 = (59)b9p68 - (91)r6c85 = (1,8)r9c56 - r345c6 = (835)b2p8214,(8)r9c6 => -58 r9c4; stte

[Mauriès Robert]

Hi Cenoman,

Thanks, I take that as a compliment, though I can't understand why and how "Kraken is TDP"...

Kraken examines what is happening on the puzzle by assuming that all occurrences of the same area (row, column or block) are valid in turn.
That's what TDP does too, but you write the chains your way (AIC) and I do it differently (TDP).
Here is how 1r9c5 is eliminated with TDP considering the 5 of C5.

Code: Select all

            -> 4r7c5 - - -
          /                \
 5r1c5 ->                   -> 1r9c6 => -1r9c5
          \                /
            -> 3r3c5 -> 8r3c6

 5r7c5 -> 2r7c2 -> 2r1c3 -> 4r6c3 -> 8r6c4 -> 1r6c5 => -1r9c5

 5r9c5 => -1r9c5


By tracing the chains on the puzzle (one color per chain) it gives :



Robert

[SpAce]

Hi Robert,

A slight issue with this:

5r7c5 -> 2r7c2 -> 2r1c3 -> 4r6c3 -> 8r6c4 -> 1r6c5 => -1r9c5

Comparing that to your grid, it's an example of the (a -> b -> c) situation I mentioned earlier, where 'c' is not implied by 'b' alone. Thus, as written, the chain is not correct as per our standards. Most of us would write it as a locked set 4r6c3 -> 81r6c45 (or even 2r1c3 -> 481r6c345). If that's not acceptable to you, then you should write it as an explicit branch:

Code: Select all

        -> 8r6c4
      /          \
4r6c3 ------------> 1r6c5

Edit. See Cenoman's diagram for a better alternative.

...or by using a memory marker to indicate that the implication depends on an earlier node as well:

4r6c3* -> 8r6c4 -> *1r6c5

It means that *1r6c5 is implied by both 8r6c4 (directly preceding node) and 4r6c3* (having the matching memory marker on its right hand side). The marker on the "sending" node is written to the right, and on the "receiving" node(s) to the left, so they point to each other. For some unknown reason some people refuse to do it that way and put them on the same side for both roles, which is obviously illogical and confusing especially if the same memory is used by multiple receivers. (I'm sure they do it just to annoy me .) Also, if more than one memory is used, they should all have distinct symbols. For (a very complex) example:

a* -> b^ -> *c -> d -> ^e% -> *f -> g -> *^h -> i -> *^%j ...

In other words, j is implied by i as well as a*, b^, and e% (which itself is implied by d and b^).

That said, we usually try to avoid memory chains (and e.g. Cenoman refuses to use them at all), but sometimes they offer an easy way out to avoid writing net diagrams or complicated split-node chains.

[StrmCkr]

Kraken examines what is happening on the puzzle by assuming that all occurrences of the same area (row, column or block) are valid in turn.

Thats is false
They are written that way for clear consice way of presenting complicated aic chains using logic gates ot very complicated set logic. With out manipulating the grid physically.

So. No they are not tdp

[Mauriès Robert]

Hi,

Kraken examines what is happening on the puzzle by assuming that all occurrences of the same area (row, column or block) are valid in turn.

Thats is false
They are written that way for clear consice way of presenting complicated aic chains using logic gates ot very complicated set logic. With out manipulating the grid physically.
So. No they are not tdp

So what are the schemes that you think identify a kraken?
Robert

[SpAce]

Kraken examines what is happening on the puzzle by assuming that all occurrences of the same area (row, column or block) are valid in turn.

Thats is false

What exactly is false in that? It's what krakens do, although Robert offers a bit limited view of them. A kraken can be formed of any strong inference set (SIS), not just the native digit-rows, digit-columns, digit-boxes, or cells (which weren't mentioned). For example, all guardians of a deadly pattern are a SIS, and their combined logic is usually presented as a kraken. The same with a multi-finned fish with indirect implications, where the "kraken" term probably originated.

Basically a kraken is a chain representation of a case-by-case analysis of a set of candidates and their implications, where it's guaranteed that at least one member in the set must be true (SIS). Thus if all members of the set can agree on some implication, that implication must be true. A SIS is just an extension of a binary strong link to include multiple strongly linked options that all must be accounted for, and a kraken is a way to present their implications as chains. Nothing more complicated than that.

They are written that way for clear consice way of presenting complicated aic chains using logic gates ot very complicated set logic.

Basic krakens are actually fairly simple. They're just AICs with multiple end points. As long as the branching chains are linear, i.e. they're trees instead of graphs, I wouldn't call it "very complicated logic" (unless it's a multi-kraken). In terms of set logic basic krakens (and even multi-krakens) don't have triplets which are responsible for most real complexity. If those are needed, then we have a net, which may or may not use kraken logic.

With out manipulating the grid physically.

I don't know what that has to do with anything. It doesn't matter how the case-by-case analysis is actually performed as long as it covers all cases and finds the common implications. It makes no difference whether it's done by eye-balling, or coloring, or running actual trials on a separate or a saved grid. In fact, most krakens are probably found as contradictions and then reversed for a nicer presentation.

Almost all of the krakens I use directly are based on deadly patterns or finned fishes or other almost-patterns. I don't think I've ever started with a basic row, column, box, or cell with multiple options to look for where they lead -- mostly because it's rarely necessary and because it's tedious to do manually. My usual coloring method only works with binary strong links, and testing multiple options at the same time requires other tricks, so I only do it with interesting SIS.

Btw, here's a nice example of a multi-kraken, by totuan. It uses six three-way krakens in the same piece of logic. It also includes two link triplets. I'd really love to know how he does that manually. Hodoku can't find that net.