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 )

Some do, some teach, the rest look it up.