Help to solve hardest puzzles

Post the puzzle or solving technique that's causing you trouble and someone will help

Re: Help to solve hardest puzzles

Postby SpAce » Sat Jul 21, 2018 10:01 am

StrmCkr wrote:SK loops are simplified versions of msls (as they were found first) and later known as virus patterns.... Then better understood as msls.

So MSLS is a more general pattern than SK Loops, and in fact includes the latter (like Exocet includes JExocets)?

using-multi-sector-locked-sets-t31222.html

That document starts in a bit confusing way:

David P Bird wrote:Using Multi-Sector Locked Sets

1. Finding Multi-fish

A working definition of a multi-fish is a combination of inconclusive fish patterns for different digits which together reveal a core set of cells that will be forced to hold one or other of the digits in the set, so allowing various exclusions to be made.

Is finding *multi-fish* part of using MSLS or what's going on? I originally thought that meant MSLS and multi-fish were synonyms, but it's been now clearly established that that interpretation was wrong.
Code: Select all
   *             |    |               |    |    *
        *        |=()=|    /  _  \    |=()=|               *
            *    |    |   |-=( )=-|   |    |      *
     *                     \  ¯  /                   *   
SpAce
 
Posts: 506
Joined: 22 May 2017

Re: Help to solve hardest puzzles

Postby David P Bird » Sat Jul 21, 2018 12:15 pm

Some background:

Cover set situations are equivalent to the supply and demand problems handled by the logistic departments in companies supplying scattered customers from different depots. These and other logistics problems fall under the heading of 'operational research' techniques - which can be used as a search term. In rank 0 patterns, the demands and supplies exactly match so that any candidate that would reduce a supply without satisfying one of the demands can be eliminated.

In MSLS all cells are considered to be either demands or supplies which makes the system comparatively straightforward to use as a general purpose approach for cases where this holds – simple fish, multi-fish, SK loops, and smaller combinations of either Naked or Hidden sets. (For fish, one of the base or cover sets is switched for the complementary set of all the other unsolved digits in the same house.) However, it has the drawback that only rank 0 patterns can be found.

Back when, Obi-Wahn posted rules for how fish patterns can be transformed which are summarised in the 'Pattern Transformations' section in the <Fish Bones Thread>. These rules can also be applied to the home and away sets used in MSLSs, when it will be found that different eliminations will be identified as being immediate consequences. However when the eliminations from any follow-on tuples are made, they will always usually produce the same result as some eliminations will simply switch categories. Together with the switching to complementary sets, this explains how the other ways of recognising rank 0 patterns can be processed.

In XSudo, users can mix the houses and cells that are considered weak and strong (demands and supplies). This makes it a powerful tool, although somewhat more laborious to use. Therefore in addition to handling rank 0 patterns, it also allows chains to be followed where the internal links in cells may be weak (a-b)r1c3 or strong (a=b)r1c3, and branched networks to be investigated.
Last edited by David P Bird on Thu Aug 30, 2018 10:51 am, edited 1 time in total.
David P Bird
2010 Supporter
 
Posts: 1040
Joined: 16 September 2008
Location: Middle England

Re: Help to solve hardest puzzles

Postby champagne » Sat Jul 21, 2018 6:59 pm

David P Bird wrote:In XSudo, users can mix the houses and cells that are considered weak and strong (demands and supplies). This makes it a powerful tool, although somewhat more laborious to use. Therefore in addition to handling rank 0 patterns, it also allows chains to be followed where the internal links in cells may be weak (a-b)r1c3 or strong (a=b)r1c3, and branched networks to be investigated.


I worked tightly with Allan Barker, so I can tell more about XSudo.

Xsudo works on sets and linksets, but can accept any "rank" logic. In fact, xsudo tests all possibilities of the sets/linksets logic to find assigned and cleaned candidates.

Allan Barker also introduced the UR threat later to give results including the fact that the puzzle has only one solution.

Xsudo can produce a sets/linksets clearing logic, but it is mainly a checking tool (very efficient)
champagne
2017 Supporter
 
Posts: 6542
Joined: 02 August 2007
Location: France Brittany

Re: Help to solve hardest puzzles

Postby SpAce » Sun Jul 22, 2018 2:12 am

David, thanks for the background info. So MSLS is indeed the most generic top dog of the family, and the other related patterns (multi-fish, SK Loops, etc) can be seen as specific instances of it? If I've finally interpreted that about correctly, then I think I've learned what I mostly wanted for now. For me it's important to understand the relationships between different patterns.

Anyway, I think I'll postpone deeper studies of MSLS and concentrate on JE first, as it seems easier to grasp. I have a specific question about that, if you're willing to answer. I took a look at the Platinum Blonde JE+, which you presented in this thread:


http://forum.enjoysudoku.com/an-elementary-solution-of-platinium-blonde-t32949.html?hilit=platinum%20blonde#p249828

Leren mentioned 34 direct JE eliminations. I tried to reproduce them and got these:

1. Basic eliminations from target: 6 eliminations
2. Incompatible base digit eliminations: 5 eliminations
3. NP(79) => 12 eliminations
4. "Rule 11: A known base digit, [or one that can only occur once in the 'escape' cells in the cross-lines], is false in the non-'S' cells in its cover houses."
=> 11 eliminations

Total 34 eliminations. Did I get them right and for the right reasons (steps 2 and 4 took me a while to figure out)? In any case I have some trouble with the next step you proposed, even though I think I understand the UR threat logic.

David P Bird wrote:When (7†)r4c8 is true (4)r5c3 must be true to stop (49)UR:r57c89
When (9‡)r4c8 is true (4)r6c23 must be true to stop (47)UR:r67c89
Therefore (4)r4c2 can never be true nor can (3)r5c3.



I get how (3)r5c3 is killed. I can't see it for the (4)r4c2. The way I see your eliminations are supposed to work:

Code: Select all


(7=9)r4c9 -> (9)r4c2 == (4)r6c23 => -4 r4c2

(7=9)r4c9 -> (9==4)r5c3 ==========> -3 r5c3

The part I don't get is how 9r4c9 -> 4r6c23. Can you walk me through?
Code: Select all
   *             |    |               |    |    *
        *        |=()=|    /  _  \    |=()=|               *
            *    |    |   |-=( )=-|   |    |      *
     *                     \  ¯  /                   *   
SpAce
 
Posts: 506
Joined: 22 May 2017

Re: Help to solve hardest puzzles

Postby StrmCkr » Sun Jul 22, 2018 6:10 am

Yes, skloops muti fish, are specific simplified versions of a msls
Some do, some teach, the rest look it up.
User avatar
StrmCkr
 
Posts: 840
Joined: 05 September 2006

Re: Help to solve hardest puzzles

Postby SpAce » Sun Jul 22, 2018 4:51 pm

StrmCkr wrote:Yes, skloops muti fish, are specific simplified versions of a msls

Thanks, StrmCkr! That's exactly what I've been looking for. It also clears up the confusion I had with this:

I wrote:
David P Bird wrote:Using Multi-Sector Locked Sets

1. Finding Multi-fish

I guess that should have been interpreted so that -- among other things -- one can use the MSLS procedure to find Multi-Fish? It's probably clear to someone who understands both techniques already, but it wasn't for me because I had no clue about either. That opened up the possibility to other interpretations, such as MSLS and Multi-Fish being synonyms, or that finding a Multi-Fish was somehow part of the procedure of using MSLS. One more possibility is that I'm just dumb :)
Code: Select all
   *             |    |               |    |    *
        *        |=()=|    /  _  \    |=()=|               *
            *    |    |   |-=( )=-|   |    |      *
     *                     \  ¯  /                   *   
SpAce
 
Posts: 506
Joined: 22 May 2017

Re: Help to solve hardest puzzles

Postby pjb » Mon Jul 23, 2018 3:38 am

If you are interested, I have amassed a large set of working examples of SK loops, multifish and MSLSs, with some explanation of the logic, on my website (www.philsfolly.net.au).

Phil
pjb
2014 Supporter
 
Posts: 2025
Joined: 11 September 2011
Location: Sydney, Australia

Re: Help to solve hardest puzzles

Postby SpAce » Mon Jul 23, 2018 5:04 am

pjb wrote:If you are interested, I have amassed a large set of working examples of SK loops, multifish and MSLSs, with some explanation of the logic, on my website (www.philsfolly.net.au).

Thanks for the tip, Phil! I was aware of your solver having those techniques implemented, but somehow I'd missed or forgot that it also had lots of examples listed in the help files. I'm sure they will help, especially once I've built a bit more theoretical foundation to understand them (and probably during that process, too). This discussion has already helped a lot by clarifying the big picture, which was necessary for my motivation to study details.
Code: Select all
   *             |    |               |    |    *
        *        |=()=|    /  _  \    |=()=|               *
            *    |    |   |-=( )=-|   |    |      *
     *                     \  ¯  /                   *   
SpAce
 
Posts: 506
Joined: 22 May 2017

Re: Help to solve hardest puzzles

Postby SpAce » Mon Jul 23, 2018 1:49 pm

Gordon, thanks for your comments to the assumptive/non-assumptive question as well. Took me a while to get back to it.

ghfick wrote:Andrew has a number of forcing chains in his solver strategy list. Some of these strategies are also sometimes called Krakens. One can have Kraken Units, Kraken Cells, Kraken Rows, Kraken Columns... There are also Kraken Fish like Kraken Finned X-Wings, Kraken Finned Swordfish....

Before biting into the main course, I'd like to say that I really don't like the term "strategy" here, even though Andrew himself uses it. None of those above are solving strategies but tactics (in the form of candidate reducing patterns). Strategy is a comprehensive plan to attack a puzzle, which includes prioritizing one's goals (efficiency, elegance, speed, etc) and choosing acceptable solving methods (p&p or software, patterns, searching techniques, etc). Andrew's solver implements a single solving strategy which is applying a list of known tactics in a predetermined order.



Many Sudoku writers would say that most, if not all, of these strategies are 'assumptive'



And what would be their argument? What exactly makes those patterns intrinsically assumptive?



To me "assumptiveness" or "non-assumptiveness" is not a fixed attribute of almost any elimination pattern. It has much more to do with the process of finding them. The most obvious assumptive technique is the classic t&e, when the player assumes a candidate (or a combination of them) to be true (or false) and then solves on a copy of the grid (possibly in their head) to see where it leads. If it results in a contradiction (or a full solution), they have learned something about the initial assumption. Otherwise they have learned nothing, and have to try another value or add a nested assumption.



Nishio is an obvious assumptive technique, but I also regard Discontinuous Nice Loops as such, even though the latter is a well-established pattern. The defining characteristic of both is that they're producing contradictions instead of verities. Of course, any elimination (or placement) can be presented as either a contradiction or a verity, so we can't really know anything about a solver's process of finding an elimination just by looking at the documented pattern. Non-assumptive patterns might well have been found using assumptive search methods, and (theoretically) vice versa.



Btw, here's an example of applying a no-limits, computer-assisted, fully assumptive strategy (no, I don't usually solve that way -- in fact, this was a first):
http://forum.enjoysudoku.com/help-to-solve-another-hardest-wu-303-t34897.html#p268156



So what is non-assumptive then? To me it is recognizing or constructing a verity-producing pattern without any a priori assumptions about what it's going to produce. The pattern itself doesn't matter -- only the process of finding it. There's logically nothing assumptive per se about Kraken patterns, or even nets, for example. However, I would bet that many Krakens and nets presented by manual solvers have been reverse-engineered from Nishio contradictions (which are usually much easier to find), but that only makes the process assumptive -- not the pattern itself (finding AICs can be just as assumptive!). No matter how they're found, most Krakens are very easy patterns to understand when presented as solution steps.



To try to prepare a definition of 'assumptive' requires a definition of a 'pattern'.



Not necessarily, though you didn't actually provide one either. You only listed examples of what you consider patterns.


An MSLS is a pattern. Its logic is clear and the MSLS pattern appears quite often in extreme puzzles.


It should be obvious by now that I, for example, don't (yet) think its logic is clear (but that's my problem, and hopefully a transient one) ;) One problem with complicated patterns is that their eliminations are obvious only to the initiated. On the other hand, well-presented net solutions (like totuan's), can be understood by anyone with an elementary understanding of sudoku rules.

Most writers would say that Exocets [that are not Junior] are not patterns.

I would say they are, but not fully self-contained ones like JEs. In many cases they're probably not practical patterns for manual solvers, but that doesn't make them non-patterns.
Once you see it [a pattern] and understand its logic, the exclusions follow from it.

Actually, you don't need to understand the logic of a well-defined and self-contained pattern, as long as you trust the pattern provider. It could just as well be a black box. You only need to recognize the pattern ("count the elements") and remember the elimination rules. Zero logic needed. I bet there are people who actually use (or code) some complicated patterns without really understanding how and why they work.

A strategy may be called 'assumptive' if its exclusions can only be seen starting with an IF statement [an assumption].

By that definition any pattern is internally "assumptive" and so is using it! Patterns are recurring and recognizable pieces of pre-packaged logic, and logic always has those IF statements (possibly hidden under higher level abstractions, such as set logic, but they're still there). You can't get rid of them by using patterns -- you just don't have to think about them, if you've memorized the elimination rules. Basically, you've replaced several if-then-else statements with a single "if pattern==true, then eliminate xxx". A pattern is nothing more than a higher level abstraction that hides logic details.

If a chain can be expressed in a bidirectional way, most authors would say that such a chain can be described as a pattern and so it is non-assumptive. If a chain can only be expressed as unidirectional, many writers would say that it is 'assumptive'.

And what would be their supporting argument? Most if not all unidirectional chains can be made bidirectional with a little tweaking, so would that make them non-assumptive all of a sudden? You basically ask the same question later, so you must know that claim is very weak. Besides, I don't see what directionality has to do with assumptiveness in the first place. A unidirectional chain with strong links at both ends establishes a derived strong link (OR) between the two ends just as well as a bidirectional one, so effectively it's always bidirectional (even if it's harder to see):

Code: Select all


~a -> b <=> a | b <=> b | a <=> ~b -> a



Thus, it's functionally no different from an AIC. 



Such a unidirectional chain must start with an assumption.



Can you elaborate? All chains, including AICs, start with an assumption. Do you mean an assumption of "node=true"? That's only true for Nishios and some Discontinuous Nice Loops which produce contradictions. All verity-producing chains and nets, whether bidirectional AICs or bi/unidirectional AIC Nets or memory chains (or Krakens), work just like AICs; i.e. they have a derived strong link between the two (or more) ends, which is used to prove a verity (or many in case of a loop). In their case the initial assumption which starts the chain is always "node=false" (including Krakens, if you start at one of the ends instead of the SIS hub as usually presented). If you think that's assumptive, then you must stop using AICs too.



[Edit: The defining difference is not whether the assumption is "node=true" or "node=false". It's whether only one of those is used in the proof. Chains that produce contradictions only use one or the other, and those are what I would call "assumptive". AICs, AIC Nets, Krakens, etc use both options (but only one starts the chain) when proving that at least one of the end nodes of the chain/net must be true (a derived SIS), and thus any candidates weakly-linked to all of them must be false. That's why they're non-assumptive by my definition.]

Here's a bit more about my thoughts on the relationships between some chaining patterns:
http://forum.enjoysudoku.com/forcing-chains-nishios-krakens-aics-dnls-t34574.html



Many chains that have 'memory' along its direction would be called assumptive.

Again, I don't think that's a fixed property of a memory chain per se. However, it's hard to imagine building a memory chain without having an a priori elimination objective in mind. The same is true for other kinds of nets and even split-node chains. I guess it would be fair to say many of them are probably assumptive from that point of view, but there's no proof unless we know how they were built. In any case, the pattern itself is no more assumptive than an AIC. 



A bidirectional chain can have nodes that are patterns of various kinds. A node [or nodes] can be ALS's, X-Wings, JEs... So all of these chains are non-assumptive.



So are unidirectional chains with the same kinds of nodes as well. No logical difference. Both are just as equally assumptive, if we know their constructing process was such.

[Edit: The nodes can also be other AICs, which means that every Kraken with linear branches can be converted into an AIC with nested AICs as boolean nodes, as demonstrated behind the previous link. If you accept that, then you must accept that (at least linear) Krakens are non-assumptive by your definitions as well.]



Many authors would say it is worthy and interesting to exhaust all non-assumptive steps in solution path construction.

And I would agree. However, it's nothing but a personal preference. It's also not a religious commandment to me, which is why I can entertain other kinds of steps as well if need be.



Some authors prefer to leave a puzzle unsolved rather than complete solution paths with assumptive steps.

Another personal preference, though not one I share. To me an ugly solution is usually better than no solution. If I've understood correctly, even the non-assumptive purist David submits to using net methods etc if he can find nothing else that works. For him that threshold is just very high for obvious reasons.



The boundary between assumptive and non-assumptive is hazy to me. A single finned Kraken X-Wing can be seen as a bi-directional chain with an X-Wing as a node. So it can be said to be non-assumptive. [maybe?] Sometimes a chain with memory appears to be unidirectional but then the reverse direction becomes apparent [perhaps with different logic] and so maybe such a chain is now non-assumptive.

Have you considered that the problem of haziness might go away if you adjusted your definitions a bit? :) My definition of assumptiveness is really easy and consistent: if you *assume* something and try it to produce a contradiction (or a full solution), then it's assumptive, otherwise not. With my definition very few patterns (mainly Nishios and Discontinuous Nice Loops) are assumptive per se. Many intrinsically non-assumptive patterns can be found using assumptive methods, though, and it's more likely for some than others.

Some authors enjoy finding a small set of strategies [sometimes even just a single killing step] that solves a difficult puzzle. There is a thread on the forum entirely devoted to finding that one crucial step.



According to a bit wider interpretation of my definition, all one-stepper solutions to the daily puzzles are very much assumptive, as they start with a known elimination target around which a proving pattern is built. The patterns themselves aren't (usually) assumptive, but the process most definitely is. Does it somehow make those ingenious solutions less interesting? I don't think so.
Last edited by SpAce on Tue Jul 24, 2018 11:40 pm, edited 3 times in total.
Code: Select all
   *             |    |               |    |    *
        *        |=()=|    /  _  \    |=()=|               *
            *    |    |   |-=( )=-|   |    |      *
     *                     \  ¯  /                   *   
SpAce
 
Posts: 506
Joined: 22 May 2017

Re: Help to solve hardest puzzles

Postby StrmCkr » Tue Jul 24, 2018 8:36 am

assumptive/non-assumptive


to chime in:

assumptive for me is anything at uses a trial and error {guess and test} approach as a direct coarse of action to prove a starting candidate or group of candidates as false/true or dead end.
the biggest issue here is applying the truths discovered as truths without the acceptance that there could be more then 1 solution in that position. { ie discard the truths, and only use the exclusions}

subnets, nisho, bowmens bingo, P.O.M, Tabling.

the next type of assumptive solving techniques that relies on a grid to already contain at least 1 solution without proving it firstly.

unique rectangles { type 1-6 + extensions}, hidden unique rectangles, almost unique rectangles, bivalve universal grave, b.u.g lite, bug +n, reverse bug, reverse bug light,
Bi Bi patterns, Jr Exocet. Exoct, {to the best of my understanding of theses techniques}
all use the assumption of 1 solution and avoid muti solutions. {and any extensions that end with a uniqueness assumption}

the third type of assumptive logic is scenario expectations: "Broken wings" aka oddigons where specific arrangements are "never" allowed to happen in a puzzle with at least 1 solution, as they could leave zero if they are true.

to me non-assumptive logic are forward and backwards generated where the elimination proves the construct to hold errors to the rules of the puzzle, and the construct proves the eliminations as never possible
: these techniques fall-under this category {probably missed some}

aic, continuous/discontinuous loops, x-chains, xy-chains, remote pairs, als- xz{double linked}, als-xy, ahs-xz, ahs-xy, subsets, distributed disjointed subset, als-chains, almost distributed disjointed subset, nxn fish, nxn+k fish, "xy,xz.wxyz, S,M,L,L2,H123,W,iW -wings", barn{s}, subset counting{aligned pair exclusion, aligned tripple exclusion}, death blossoms, sue de coq, T-chains, Z-chains,g-whips, whips,lasso's, c.o.a.L.s, braids, colouring, muti-colouring, 3d medusa colouring, turbots, kraken, sk-loops, mutifish, msls, virus patterns, Sharks, " Transport/irregular -chains,wings + a host of extensions"


How are these methods non assumptive if the search method in finding them can be considered a "trial and error" approach if its blinding searching for a construct?

the programs do not blinding search every possible connection/combination instead they are keyed to follow all valid construct paths within the group type and data used: {yes some paths do terminate }

most dead ends arrived at are from finding constructs whoms eliminations are already preformed.{which can also be programed around} which is finite tree searching, as the search tree can only grow based on the number of connections in said path

the biggest difference in all of these types is the data sets/types they use to mathematically prove the construct is sound:

for me there is 3 different types of data:
graphing node methods to bridge points together, {Aic, Nice loops} {strong - weak linkages}
direct mathematical constraints of placement. {fish,mutifish } [N sector intersections with exactly N candidates ]
set theory, {finite placement of a group of objects within closed systems of same number of containers } { N cells with N candidates }

the fun part is that every single one of the techniques has a direct counterpart with identical eliminations in the other 2 methods.

now the biggest thing on this forum was and still is to the best of my knowledge is anything labeled "Kraken" is considered trial and error approach, by some of the oldest members here as it takes a "technique set" that is incomplete or terminated and extends it through another technique set to have an elimination occur.

examples:
http://forum.enjoysudoku.com/fin-transport-irregular-xy-wings-aka-kraken-fish-t33596.html
http://forum.enjoysudoku.com/strong-links-within-fish-patterns-t30392.html

the other one that some might call assumptive is anything from denis's "hidden logic of Sudoku" where some of his technique "hold" known information/potential arrangements and carries it forward within a fixed network deriving an out come {g-wings, T-chains, z-chains, whips etc}. however I do have multiple posts where his methods match other known techniques that are considered sound, so i find it hard to argue they aren't logically sound when they use graphing theory based on my copy of implemented code from himself and some advocates for his methods.

my 2 cents.
strmckr


According to a bit wider interpretation of my definition, all one-stepper solutions to the daily puzzles are very much assumptive, as they start with a known elimination target around which a proving pattern is built. The patterns themselves aren't (usually) assumptive, but the process most definitely is. Does it somehow make those ingenious solutions less interesting? I don't think so.

SpAce

Posts: 251
Joined: 22 May 2017

Top
not really, most of use hierarchy changes in some programs {like hodoku} to reduce the step counts lower and lower until we land on fewest steps possible. ie sorting of all valid moves at each phase of the puzzle and applying only the most critical.

we could use gsf's tool to locate the magic cells {back door size and locations} to probably a quicker targeted searching on eliminations with them only existing on the "key" cells found.

some still manually find some nifty move :)
Some do, some teach, the rest look it up.
User avatar
StrmCkr
 
Posts: 840
Joined: 05 September 2006

Re: Help to solve hardest puzzles

Postby SpAce » Tue Jul 24, 2018 10:08 pm

Nice analysis, StrmCkr. Your definitions of "assumptive" are obviously much wider than what I suggested, but they're all logical. I can't say the same for Gordon's definitions, at least without better arguments, even if they're shared by "many/most authors" as he claims several times. Sound logic is not decided by a democratic process or by authority figures :)

All the evidence suggests that the terms "assumptive" and "non-assumptive" have so many varying definitions in this context, some having no logical connection to the general meanings of the words, that they're rendered meaningless and should be avoided. They convey little to no information and only promote confusion and chaos (not to mention fruitless debates), as far as I'm concerned. That's my conclusion from all of this.
Code: Select all
   *             |    |               |    |    *
        *        |=()=|    /  _  \    |=()=|               *
            *    |    |   |-=( )=-|   |    |      *
     *                     \  ¯  /                   *   
SpAce
 
Posts: 506
Joined: 22 May 2017

Re: Help to solve hardest puzzles

Postby totuan » Mon Aug 20, 2018 2:48 pm

WU-309

100002005090600040003000700080906000000050000000840090005000300060004020700000001

Code: Select all
 *-----------------------------------------------------------------------------*
 | 1      (47)      4678   | 347     3789    2       | 689    (368)     5      |
 |(258)    9       (278)   | 6       1378    13578   |(128)    4       (238)   |
 | 24568  (245)     3      | 145     189     1589    | 7      (168)     2689   |
 |-------------------------+-------------------------+-------------------------|
 | 2345    8       1247    | 9       1237    6       | 1245    1357    2347    |
 | 23469   12347   124679  | 1237    5       137     | 12468   13678   234678  |
 | 2356    12357   1267    | 8       4       137     | 1256    9       2367    |
 |-------------------------+-------------------------+-------------------------|
 | 2489   (124)     5      | 127     126789  1789    | 3      (678)     46789  |
 |(389)    6       (189)   | 1357    13789   4       |(589)    2       (789)   |
 | 7      (234)     2489   | 235     23689   3589    | 45689  (568)     1      |
 *-----------------------------------------------------------------------------*

Just for first moved:
Look at r28c28 => SK loop:
(13=89)r8c13-(89=57)r8c79-(57=86)r79c8-(86=13)r13c8-(13=28)r2c79-(28=57)r2c13-(57=24)r13c2-(24=13)r79c2
=> r8c5<>89, r9c7<>5, r7c9<>7, r5c8<>86,r1c7<>8, r3c9<>8, r2c56<>8, r1c3<>7, r3c1<>5, r5c2<>24, r6c2<>2

The Puzzle downgrade to ER9.0
Edit: based on pjb comment :oops: and more...

totuan
Last edited by totuan on Tue Aug 21, 2018 4:01 pm, edited 2 times in total.
totuan
 
Posts: 16
Joined: 25 May 2010
Location: vietnam

Re: Help to solve hardest puzzles

Postby SpAce » Mon Aug 20, 2018 8:46 pm

totuan wrote:Look at r28c28 => SK loop:
(13=89)r8c13-(89=57)r8c79-(57=86)r79c8-(86=13)r13c8-(13=28)r2c79-(28=57)r2c13-(57=24)r13c2-(24=13)r79c2
=> r8c5<>89, r9c7<>58, r7c9<>78, r5c8<>86, r1c7<>8, r3c9<>8, r2c56<>8, r1c3<>7, r3c1<>5, r5c2<>24, r6c2<>2

That's a very nice and easy to understand example of an SK Loop. Thanks!
Code: Select all
   *             |    |               |    |    *
        *        |=()=|    /  _  \    |=()=|               *
            *    |    |   |-=( )=-|   |    |      *
     *                     \  ¯  /                   *   
SpAce
 
Posts: 506
Joined: 22 May 2017

Re: Help to solve hardest puzzles

Postby pjb » Tue Aug 21, 2018 2:17 am

The SK loops produces 13 eliminations as above, but interestingly the MSLS (16 direct and 10 follow-on singles) produces 26 eliminations and the Multifish 18. Contrary to what I've read elsewhere, these 3 rank zero strategies commonly produce different eliminations.

MSLS:
16 cell Truths: c1379 r2468
16 links: 35c1, 17c3, 15c7, 37c9, 28r2, 24r4, 26r6, 89r8
16 eliminations: r2c5<>8, r2c6<>8, r4c5<>2, r6c2<>2, r8c5<>8, r8c5<>9, r3c1<>5, r5c1<>3, r1c3<>7, r5c3<>1, r5c3<>7, r5c7<>1, r9c7<>5, r5c9<>3, r5c9<>7, r7c9<>7, then r5c4 = 2, etc

Multi-Fish pattern with base set of 1357
16 Truths = {1357R2, 1357R4, 1357R6, 1357R8}
16 Links = {35c1, 17c3, 137c5, 15c7, 37c9, 2n6, 4n8, 6n2, 6n6, 8n4}
18 Eliminations: r2c6<>8, r6c2<>2, r1c3<>7, r1c5<>3, r1c5<>7, r3c1<>5, r3c5<>1, r5c1<>3, r5c3<>1, r5c3<>7, r5c7<>1, r5c9<>3, r5c9<>7, r7c5<>1, r7c5<>7, r7c9<>7, r9c5<>3, r9c7<>5

Phil

PS Totuan, how do you get the eliminations -8 r9c7and -8 r7c9?
pjb
2014 Supporter
 
Posts: 2025
Joined: 11 September 2011
Location: Sydney, Australia

Re: Help to solve hardest puzzles

Postby David P Bird » Tue Aug 21, 2018 9:55 am

pjb wrote:The SK loops produces 13 eliminations as above, but interestingly the MSLS (16 direct and 10 follow-on singles) produces 26 eliminations and the Multifish 18. Contrary to what I've read elsewhere, these 3 rank zero strategies commonly produce different eliminations.

Phil, Perhaps you are referring to my post of 21st July above.
I wrote:Back when, Obi-Wahn posted rules for how fish patterns can be transformed which are summarised in the 'Pattern Transformations' section in the <Fish Bones Thread>. These rules can also be applied to the home and away sets used in MSLSs, when it will be found that different eliminations will be identified as being immediate consequences. However when the eliminations from any follow-on tuples are made, they will always produce the same result as some eliminations will simply switch categories.

I still stand by this. Whichever of the three treatments is used, when all the automatic follow-on eliminations are made, we will reach the same end result. I kept my description short, but some internal eliminations swap with some external ones, however there isn't a one-to-one relationship. For me there is nothing to be gained by choosing the approach that gives the most immediate eliminations.

However, by adding one more set to the SK Loop coverage for (137)r5, I get this:
MS-NS: 19 digits, 19 cell covers (28)r2, (137)r5, (89)r8, (24)c2, (68)c8, (57)b1, (13)b3, (13)b7, (57)b9
Eliminations 18 digits in 13 cells 7r1c3, 8r2c5, 8r2c6, 5r3c1, 3r5c1, 17r5c3, 137r5c4, 1r5c7, 37r5c9, 2r6c2, 7r7c9, 89r8c5, 5r9c7

I agree with you that the (8) eliminations in box 9 don't follow from the rank 0 patterns.

David PB
.
David P Bird
2010 Supporter
 
Posts: 1040
Joined: 16 September 2008
Location: Middle England

PreviousNext

Return to Help with puzzles and solving techniques

cron