The New Sudoku Players' Forum

[David P Bird]

I had to change your "5Fish:r4c6b137\r126c37" to "5Fish:r4c26b13\r126c37" to make it work. This starfish has two fins -- local fin r9c2 and remote endo-fin r2c2.

Ronk, this morning I've been looking at this substitute mutant 5fish of yours.

If the fish body is true then clearly r9c3 must be false
However I can find no inference stream to follow when either of the fins is true and it must be split into cases:
If your local fin at r9c2 is true, it kills r9c3 directly
If your remote endo fin r2c2 is true then a net shows that r4c3 is true, again killing r9c3.

I think we can agree that this isn't a "recognisable" pattern and requires analysis. But to me the analysis it requires takes it almost into the realms of the templating that you're trying to avoid - I have little idea of where you draw the line on what's acceptable and what isn't.

I know I'm making a rod for my own back, but I'm trying to use the inferences available from balancing the number of truths in the base and cover sets in linear alternating inference streams. (The path I followed isn't such a problem using Eureka notation, but I guess it's trickier using Nice Loops.) However, it seems that our respective goals are miles apart.

[ronk]

I had to change your "5Fish:r4c6b137\r126c37" to "5Fish:r4c26b13\r126c37" to make it work. This starfish has two fins -- local fin r9c2 and remote endo-fin r2c2.

I've been looking at this substitute mutant 5fish of yours.

If the fish body is true then clearly r9c3 must be false
However I can find no inference stream to follow when either of the fins is true and it must be split into cases:
If your local fin at r9c2 is true, it kills r9c3 directly
If your remote endo fin r2c2 is true then a net shows that r4c3 is true, again killing r9c3.

For finned fish, the argument has always been ... "either the fish is true, or at least one of the fins is true." By definition, this is an argument by cases.

Furthermore, fish on this thread are treated primarily as constraint set problems, where inference streams (chains) shouldn't even be a factor. Unfortunately, chains are needed for remote fins, but I see no need for a chain or net expression between fins.

... it seems that our respective goals are miles apart.

No argument there, it seems.

[daj95376]

For finned fish, the argument has always been ... "either the fish is true, or at least one of the fins is true." By definition, this is an argument by cases.

Furthermore, fish on this thread are treated primarily as constraint set problems, where inference streams (chains) shouldn't even be a factor. Unfortunately, chains are needed for remote fins, ...

Amen !!!

My opinion on remote/Kraken fins ...

Your original post about this grid asked if it was a Fish or NoFish. Since David's solution falls into the NoFish category, there are no guidelines on what is acceptable or not. I think it's acceptable for David to identify and then use an embedded Fish constraint in his NoFish network solution.

Now, the question remains as to whether or not one network solution is preferable over another for the elimination.

[David P Bird]

Danny, thanks for your support and I appreciate that at least one person made the effort to follow my solution.

Ronk I could take issue over almost every point in your reply, but experience shows it would be counter-productive. I think it best for my blood pressure (and perhaps yours) just to say that we agree to differ and leave it there.

[daj95376]

Taking another look at my Jellyfish.

Code: Select all

 finned Franken Jellyfish c129b5\r1256 w/fins r9c12
 +-----------------------------------+
 | *7  . ~7  |  . ~7 ~7  |  .  .  .  |
 |  . *7  .  |  .  .  .  | ~7  . *7  |
 |  .  .  7  |  .  7  .  |  7  .  .  |
 |-----------+-----------+-----------|
 |  .  .  7  |  .  .  .  |  7  .  .  |
 | *7  .  .  |  . *7  .  | ~7 ~7 *7  |
 | *7 *7  .  |  .  . *7  |  .  .  .  |
 |-----------+-----------+-----------|
 |  .  .  .  |  7  .  .  |  .  .  .  |
 |  .  .  .  |  .  .  .  |  7  7  .  |
 | #7 #7 -7  |  .  .  .  |  .  .  .  |
 +-----------------------------------+


Code: Select all

 fins assumed false  =>  unfinned Jellyfish true  =>  all PEs become EEs
 +-----------------------------------+
 | *7  .  .  |  .  .  .  |  .  .  .  |
 |  . *7  .  |  .  .  .  |  .  . *7  |
 |  .  .  7  |  .  7  .  |  7  .  .  |
 |-----------+-----------+-----------|
 |  .  .  7  |  .  .  .  |  7  .  .  |
 | *7  .  .  |  . *7  .  |  .  . *7  |
 | *7 *7  .  |  .  . *7  |  .  .  .  |
 |-----------+-----------+-----------|
 |  .  .  .  |  7  .  .  |  .  .  .  |
 |  .  .  .  |  .  .  .  |  7  7  .  |
 |  .  . -7  |  .  .  .  |  .  .  .  |
 +-----------------------------------+


At this point, r1c1, r6c6, and r9c3 are forced true. This results in all of the candidates in [b4] being eliminated.

Since we now know that all fin cells can't be false, r9c3<>7 follows.

[ronk]

Taking another look at my Jellyfish
...
At this point, r1c1, r6c6, and r9c3 are forced true. This results in all of the candidates in [b4] being eliminated.

I see r1c1, r6c2, r5c5 and r2c9 forced true ... resulting in an empty b2. This suggests that your NoFish should have b2 as a base set member ... and that r9c12 are guardians to an illegal starfish, with which I'm not familiar.

[daj95376]

I'm sure there are a number of fish that could produce results similar to mine and use the sectors you mentioned. I didn't need those sectors, so I didn't use them.

Likewise, there are five Singles -- r1c1, r3c5, r6c6, r8c8, and r9c3 -- exposed/forced by assuming the fins were false. I only needed (and used) three of them to make my point -- that the candidate grid couldn't support the unfinned fish being true.

For NoFish grids, I think it's often going to boil down to the candidate grid not being able to support an unfinned fish ... and peers of the fin cells being eliminated.

[JC Van Hay]

Ronk, the NoFish is equivalent to the one I gave on the previous page as "A NoFish Solution" . Simply replace c56 by b25 in the base to get the invalid Starfish c129b25/r12356.

To all : Why not simply admit, once for all, that the fish logic is false, that the fish logic is not a constraint set problem !?

JC

[ronk]

I'm sure there are a number of fish that could produce results similar to mine and use the sectors you mentioned. I didn't need those sectors, so I didn't use them.

Likewise, there are five Singles -- r1c1, r3c5 ...

r3c5 would make sense if 7b2 was one of your strong sets i.e., base sets. It's not!

To all : Why not simply admit, once for all, that the fish logic is false, that the fish logic is not a constraint set problem !?

I see no basis for such a statement. Indeed, every sudoku deduction can be viewed as a constraint set problem.

I agree on your and daj95376's NoFish equivalence.

[David P Bird]

When we define a pattern such as an XY-Wing, there is a certain set of cells that are proved must contain a particular digit. This allows that digit to be eliminated from cells that see all the cells in that set.

In inference terms we establish a strong inference between two nodes within the pattern cells killing the candidates that are weakly linked to both. Note that, apart from the exclusion cells, all the cells that are used to build up the inference are internal to the pattern.

For a simple fish elimination we establish a strong inference between the set of fin cells and any set of body cells completely contained by a cover constraint. For convenience, because there are several cover constraints, we mark all the candidates that are weakly linked to body cells in each of them as PE's. Now any PE that sees all the fin cells can be eliminated. But again note that all the cells involved in building up the inference are contained within the fish pattern (ie the cells covered by the two constraint sets).

Now, when a strong inference available from an XY wing pattern is extended by chains to provide an exclusion out of sight of the pattern cells, we stop calling it an XY-Wing exclusion. But in this thread we have a stampeding herd of elephants extending the fish inferences using branched inference streams involving multiple strong inferences external to the fish pattern and but still considering them to be basic fish exclusions.

Depending on one's personal acceptability criteria there may be nothing wrong with these deductions, but what's wrong is what everyone here is calling them. Either the patterns must be extended so only the elimination cells are external to them, or we should admit that the eliminations are hybrids between fish and branched or un-branched chains.

It also seems that In this confusion some of us have lost sight of the fact that if a mixed node made up of a combination of fin and PE cells is true, N body cells can't be true and the full set of fin cells must contain a truth. It's inconvenient that proving this depends on the use of nodes that overlap, but to refuse to accept this logic because our existing tools can't handle it is rather unwise. After all, we're trying to extend our analysis skills aren't we?

[daj95376]

[mea culpa]

[David P Bird]

Interesting position David. However, it does have a wrinkle. The logic behind constraint sets forming a Fish does not include fin cells.

That's not the interpretation of what constitutes a fish pattern that I (and I believe most other people) use. The cells internal to the full pattern are those in each of the constraint sets used. Of these, the ones that are covered equally by both constraint sets make up the fish body cells and the others are empty, fins, or PEs.

Now the primary strong inference is: either the fin cells must hold a true candidate or the body cells must hold N true candidates, one in each of the defining constraints.

The weak inferences are: either any selected node of fin and/or PE cells is false or the body cells can't hold N truths.

There are knock on inferences too though; firstly because the base and cover sets are reversible, and secondly because the number of base constraints satisfied by fins must equal the number of cover constraints satisfied by PEs.

Danny, we see things from different perspectives. What I consider an un-branched chain you see as a net. I don't know why this is but suspect that it has to do with your choice of start point, and perhaps failing to consider all the inferences being used are bidirectional. If I start in the middle and produce two chain stubs to find an elimination, I simply switch the start point to stub one end and follow that stub in reverse to produce the un-branched chain. I don't see anything wrong in that.

When there's a fish that's got a valid construction but can't impossibly hold N truths, I will only use it if I can prove that it's impossible without resorting to nets – that's what I consider to be the Dark Side! For example, I'll accept that fish are impossible if their body cells contain impossible loops but no guardian cells.

[daj95376]

Interesting position David. However, it does have a wrinkle. The logic behind constraint sets forming a Fish does not include fin cells.

That's not the interpretation of what constitutes a fish pattern that I (and I believe most other people) use. The cells internal to the full pattern are those in each of the constraint sets used. Of these, the ones that are covered equally by both constraint sets make up the fish body cells and the others are empty, fins, or PEs.

Now the primary strong inference is: either the fin cells must hold a true candidate or the body cells must hold N true candidates, one in each of the defining constraints.

The weak inferences are: either any selected node of fin and/or PE cells is false or the body cells can't hold N truths.

Mea Culpa !!! I forgot that the definition of Fish includes the fin cells along with the constraint sets. I have no idea what caused me to make such a gross blunder. My apologies for the waste of time!!!

[Pat]

a "leaf fish" is very flat
and can be mistaken for a leaf

[StrmCkr]

edited for simplicity

my current fish finder is based on a cross between Obi-Wahn Mathematics and Set wise Mathmatics submitted by Rudd/ronk/pat

I read it as missing some explanations &/or rules to have them function directly as is written so here is my application of sets:

my application is based on the notation that there is an intersection of units between Base and Cover in order for the base x cover set to eliminate candidates
there must be no candidates outside this intersection in the base sectors; then the cover cells not in the intersection can be eliminated.

Setwise operations

+ Union of two sets
- Difference of two sets
* Intersection of two sets
= Checks equality of two sets
<> Checks non-equality of two sets
in Checks set membership of an element in a set
".. " operator precedence

notes:

My version dose not need to add the same sectors multiple times to adjust the counts as seen in obi's math: in fact my system doesn't count, because i do not count each sector can only be used once.
this is based on his idea that counting occurs, however i deduced that the only counting that is relevant to eliminations is derived from the overlapping cover units, ie Row,Box,Col cell intersections.
From obi's idea that the count for eliminations must be > K , there by extension that cover intersections used to perform eliminations must be in multiple overlaps.
at most the number of overlaps for a cells is at max 3: which is col*box*row, and 2 being the minimal occurs from: Row*Col, Row*Box, Box*Col
tie this relevancy into fish eliminations as outlined by pat: here and we get the following concept:

Code: Select all

N = # of sectors to use
N = sector selected from [ 1..27 ] sectors representing Row 1 - 9, Col 1 - 9, Box 1-9]
K = addition N sectors:  {at max 2 additional cover sectors}
 no selected sector can be used twice. .   
     
Base = all occupied cells in each N sector selected

BI = all occupied overlapping cells in each N sector * the previous sectors used. 
  BI = (base[1] * base[2]) + (base[1] * base[3]) + ....+ (base[n-1] * base[n])
 
Pbi =  common peer cells of each BI cell
   PBi = Peer[1] * Peer[2] * ... *  Peer[N]

Cover = all occupied cells in each  N + K sector selected
   Row_Cover = all occupied cells in each N+K sector: where N+K in [1..9] sector
   Col_Cover = all occupied cells in each N+K sector: where N+K in [10..18] sector
   Box_Cover = all occupied cells in each N+K sector: where N+K in [19..27] sector
     

Type I:

Code: Select all

      IF (bI = [ empty ]) and  ((cover * base) = base)
        then
             if K = 0 then exclude: (cover - base )
             if K = (0 or 1) then exclude: ( ( (Row_Cover * Box_cover) + (Row_Cover * Col_Cover) + (Box_cover * Col_Cover) )  - base )
             if K  > 1 then  exclude: ( ( Row_Cover *Box_cover * Col_Cover) - base )

Type 2:

Code: Select all

      IF (bI = [ Cells ]) and  ((cover * base) + bi = base)
        then
             if K = 0 then exclude: (Pbi * (cover - base ))
             if K = (0 or 1) then exclude: (  (Pbi * ( (Row_Cover * Box_cover) + (Row_Cover * Col_Cover) + (Box_cover * Col_Cover) ) )  - base )
             if K  > 1 then  exclude: ( (Pbi * ( Row_Cover *Box_cover * Col_Cover)) - base )