The New Sudoku Players' Forum

[sultan vinegar 2]

another view is the almost fish + Almost fish

b12457 / c12345 => r2589c6 not covered
+
r9 / c9 => r9c123 not covered

combined :
the cells cover's of (r9- fish) not in the base are excluded => r78c2 {which is using r123 as cover's : from the link fish}
the cells of the covers of b12457 not in the base are excluded => r9c6 { which is using c6 from the linked fish}

more specifically if r9c6 is true for both 1 fish and the large fish, as its base for both fish then they are both reduced to n-1 cells for n vertexes.

which is a rule* i was trying to devise for my nxn+k fish after i noticed that
r1 covered by C123 {K+2} mimicked R1/b1 for a 1 fish { where r1/c123 =>> peers of the base * {union of the covers} = eliminations }

a system for converting sectors that could swap for alternative covers. but in the case of this almost fish the union in theory functions for r78c2 elim.

other then that's as far as i got the idea off the ground or out of excel, when i first was testing it like 6+ years ago.

I can't make that combination work, sorry. Presumably the r9/c9 is a typo that should be r9/c6? But then are you trying to use your two almost-fish in an AIC? If so, then I can get so far as

r9c123=r9c6-r25c6=large fish

but then I don't see the utility of the large fish, for if it be true, then it eliminates only r7c4, doesn't it?

Also, I don't see the utility of having B147 in the base and c123 in the cover — that's the whole left tower in both the base and the cover; it carries no information to the fish.

[StrmCkr]

Yes that's a typo

The utility is that it locks 2 sectors up so that box col are fix thus row is also locked.

Which makes the loop when the almsot Blr is paired with the fish

[sultan vinegar 2]

My apologies, I still don't have it. Are you trying to do this:

[r9c123, r25c6] = Mutant Whale: R9B12457/c123456 => r9c6 <> 8.

But r9c6 is a member of the base, so it doesn't actually get eliminated.

So though the combined mutant whale is true when its five (remote and endo) fins are false, it doesn't eliminate r9c6.

I mistakenly thought that by large fish you meant the larger of the two almost fish not the combined finned mutant whale.

[StrmCkr]

Shape of Fish:

1. Basic: N row sectors x N column sectors or vv.
2. Franken: N (rows+Nonet) sectors x N (columns+Nonet) sectors or vv.[/b]
3. Mutant: N sectors x N sectors (That is not Basic nor Franken)

I'm wondering if SHAPE can be More Generalized as i stumble upon some issues with my recent rebuild.

specifically with Franken
(Box[A] + Row[] ) / (Box[B] + Col[] )

the problem is:
if Box[A] is empty we have : (Row ) && (box[b] || (Col )
if Box[B] is empty we have : (Box[a] & (Row[] ) && (Col)

which doesn't conform to the Franken definition above
to make it match the definitions: I treat it as a union ( Box[a] && Row) && (Box[b] && Col) must be true

which makes these two cases show up as "Mutant", which doesn't match HODOKU which labels them as "Franken"

to match Hodoku I'D have to "OR" the truths

(Box[A] || Row ) & ( Box[B] || Col)

for simplistic example box cannot cover box one of the sides will be off
which gives us two directions:

(Row ) & (Box[b] || Col)

(Box [A] || Row) & ( Col )

[which means i can actually just do a Union instead of "or"-> which is what my code actually does]

The Main issue I have here is if i use a "OR clause.
what if the "|| Col " or the "|| row" happens to be "false" under these Pretenses
ie
(Row ) & (Box[b] )
( Box [A] ) & ( Col )

these under the "or" show up as "franken" where hodoku classes them as "mutant"
and under the "union" version they show up as a "mutant" for mine and hodoku

should these not be of type "Basic": ???

All base N sectors are of one type[R,C,B] x All Cover N sectors are of one type[R,C,B]: where cover type <> base Type.

Notes to Align this theory goes right down to classifying Cyclops Fish
R/B => presently sets this as "Mutant" this should be "basic" ??
R/C => basic

Code: Select all

basic:    [ present  rules ]
   (base Rows && cover Cols)  ||  (base Cols && Cover rows) 
 
Purposed additions:
      ||( base Box && cover row )|| (base Box && Cover Col) 
       ||( base Col && cover Box )|| (base Row && Cover Box)   

Franken: 
            [sited definition conformity ]
          ((base Row && Base Box ) && (Cover Col &&  Cover box))  ||( (base col && Base Box ) && (Cover row &&  Cover box) )}

           [added union conditions to match Hodokus output ]       
          ((base Row ) && (Cover Col &&  Cover box)  )|| ((base col ) && (Cover row &&  Cover box))
          ((base Row && Base Box ) && (Cover Col )   ) || ((base col && Base Box ) && (Cover row )) 

everything else
 Mutant
     specifically this would be any n base x n cover  that use R/C/B intermixed    thats neither basic nor Franken .


[blue]

I think the definitinos are meant to be read like this:

1. rows covered by columns -> Basic
   columns covered by rows -> Basic
2. When at least one sector is a box sector ("Nonet"):
   (rows and/or boxes) covered by (columns and/or boxes) -> Franken
   (columns and/or boxes) covered by (rows and/or boxes) -> Franken
3. Anything else -> Mutant

The Main issue I have here is if i use a "OR clause.
what if the "|| Col " or the "|| row" happens to be "false" under these Pretenses
ie
(Row ) & (Box[b] )
( Box [A] ) & ( Col )

these under the "or" show up as "franken" where hodoku classes them as "mutant"
and under the "union" version they show up as a "mutant" for mine and hodoku

I think they're Franken Fish, but others might disagree ... including Hodoku, it seems.

Aside:

If it's fish for X-Sudoku, and one of the sectors is a "diagonal", then what (?) ... Mutant, always ... or is a diagonal a "nonet" ?
Probably that wasn't a consideration at the time.

[denis_berthier]

I think the definitinos are meant to be read like this:

1. rows covered by columns -> Basic
   columns covered by rows -> Basic
2. When at least one sector is a box sector ("Nonet"):
   (rows and/or boxes) covered by (columns and/or boxes) -> Franken
   (columns and/or boxes) covered by (rows and/or boxes) -> Franken
3. Anything else -> Mutant

Does there remain anything else?

Aside:

If it's fish for X-Sudoku, and one of the sectors is a "diagonal", then what (?) ... Mutant, always ... or is a diagonal a "nonet" ?
Probably that wasn't a consideration at the time.

For me, it's Franken:

As I see it:

Code: Select all

- If same number of base and cover sets:
 then what makes the main logical difference is: can the base sets intersect each other and can the cover sets intersect each other?
----- If "no" to both questions: Basic
----- if "yes" to at least one question: Franken
- if more cover sets than base sets: mutant

This distinction is particularly useful in Pandiagoinal Latin Squares, where all the following combinations can be considered as Basic (and can indeed be deduced from each other by isomorphisms):
- rows covered by columns
- rows covered by diagonals
- rows covered by anti-diagonals
- columns covered by rows
- columns covered by diagonals
- columns covered by anti-diagonals
.

[StrmCkr]

I've seen no-net used to represent other sector constraints ~ like jigsaw,windowku, x sudoku etc.

~For puzzles that don't have boxes (Latin squares for example)

Which is probably why boxes are classed as no net.

Still pondering this as the row/box version is a strange quirk to be mutant.

I think it should be Franken when considering variations that don't have box constraints as a base set.
..

[blue]

I think the definitinos are meant to be read like this:

1. rows covered by columns -> Basic
   columns covered by rows -> Basic
2. When at least one sector is a box sector ("Nonet"):
   (rows and/or boxes) covered by (columns and/or boxes) -> Franken
   (columns and/or boxes) covered by (rows and/or boxes) -> Franken
3. Anything else -> Mutant

Does there remain anything else?

A "2-String Kite" can be seen as a finned 2x2 fish -- rc/rb or rc/bc.
It has two issues that violate the Franken-FIsh requirement.

1. It has both a row and a column in the base
2. Depending on which cell is designated as the "fin", it has either a row in the base and a row in the cover, or a column in the base and a column in the cover.

[denis_berthier]

OK.

[StrmCkr]

"or" in boolean logic is represented as a "+" symbol

if that's the correct context coupled with Non R/C sectors being classed as a No-Net for purposed of generalized puzzles

{base} R+b x {cover} C+B or VV
{which makes more sense the longer i look at it}

then it would be like this for

Code: Select all

 franken 
              base && cover                       ||    base && cover 
 (((R && B) || B) &&   ((C && B ) || B)  )|| ( ((C && B) || B) &&   ((R && B ) || b))

I'll have to see if i can get that to work in my code

as for the 2 string kite its under N x N+K
RC / RCB constructs and since we don't know which one is the "fin sector" .... its always mutant...

[StrmCkr]

i wrote my Fish finder code before my car accident 14 years ago.. so bear with me as i am relearning what my code is doing to rebuild my solver as a gui:

my next quandary is a oddity:

rules for adding cover sectors, I had this as a rule in my original code:
each cover sector added must have a vertex of the base Sectors

DOES the vertex actually have to have a candidates?
{does this rule actually need to be there at all}

000000000000000000000000000000000000000000000000000000000000000000000000000000000

Code: Select all

+---------+---------+---------------+
| 1  1  1 | 1  1  1 | -1   -1   -1  |
| .  .  . | .  .  . | (1)  (1)  (1) |
| 1  1  1 | 1  1  1 | -1   -1   -1  |
+---------+---------+---------------+
| .  .  . | .  .  . | .    .    .   |
| .  .  . | .  .  . | .    .    .   |
| .  .  . | .  .  . | .    .    .   |
+---------+---------+---------------+
| .  .  . | .  .  . | .    .    .   |
| .  .  . | .  .  . | .    .    .   |
| .  .  . | .  .  . | .    .    .   |
+---------+---------+---------------+

Size : 1 x 1
Franken Cyclops: (1), base r2, cover b3 => b3p123789 <> 1

Size: 1 x (1+1)
Franken Cyclops: (1), base r2, cover c7,b3 => r13c7 <> 1
Franken Cyclops: (1), base r2, cover c8,b3 => r13c8 <> 1
Franken Cyclops: (1), base r2, cover c9,b3 => r13c9 <> 1

I can Remove any (1) position of R2C[7 or 8 or 9] from the Base sector [c2]
and the size 1 still applies,
but the size (1x(1+1)): would remove the c7 or c8,or c9 version.
{ which makes me question the first part of the "rule" }

My testing code didn't have this Rule at all for vertex checking and it resulted in some interesting Fish but didn't have any elims so far that would indicate errors
{all i'd need is 1 example that debunks this omission of rule and THESE just outright look wrong,}

Size 1 x (1+1)
Mutant Cyclops: (1), base r2, cover r1,b3 => r1c789 <> 1
Mutant Cyclops: (1), base r2, cover r3,b3 => r3c789 <> 1

Size 1 x (1+2)
Mutant Cyclops: (1), base r2, cover r1,c7,b3 => r1c7 <> 1
Mutant Cyclops: (1), base r2, cover r3,c7,b3 => r3c7 <> 1

elimination rules are

Hidden Text: Show

Code: Select all

nxn
 { cover - base }
 {(2 sector intersection Cover Cells)  - (cover-base) } 
 {(3 sector intersection Cover Cells)  - (cover-base) } 

nxn+1
    { overlapping cover cells  - base }
   {(3 sector intersection Cover Cells)  - (cover-base) } 

n*n+2
 {(3 sector intersection Cover Cells) - base) }   

which is why this seems to be working as goofy as they look its "increasing" the K value of the cover cells for eliminations, which is only possible if the base/cover is already true
adding sectors just "limits" what they can already eliminate ....

i'll delete this after i get a reply... as it "not really" fish related as covered in this thread.

DM also works

[yzfwsf]

I think this rule is necessary, otherwise adding a cover house would be redundant. Additionally, I believe that the fish finding code should focus on finding the smallest cover set set for a specific base set to completely cover the base set, rather than finding a cover house for each elimination.

[StrmCkr]

the above ? mostly arrives as my solver is "set" based and adds a set of "Covers" , and if it was order of 1by 1 some of the higher K structures are valid yet reduced eliminations. changing the order off applied cover sectors it could remove the inclusion of some of them

i did add the rule in after i notice it was lacking, in the filter portion of the set id code we removed the odd ones that clearly had no vertex..

my code is set up as a find all, i'll be adding in the "set" found filter for higher order logic to exclude ones that have it as a full "subset" to avoid the reduced new displayed fish as seen in the above questions..

it is rather interesting that they still operated with out needing a base Cell vertex.. just figured id ask in here