Hi David
David P Bird wrote:I have tried but failed to produce a precise definition of a Sudoku pattern. At every attempt, wherever I tried to draw a boundary line, I found I was either excluding acceptable patterns or including unacceptable ones. Consequently now I just resort to the spirit of the intention.
David P Bird wrote:However you and I have different goals, for you it's an efficient computer solver and for me it's logical constructs that can be applied by someone with sufficient patience to look for them in favour of guessing or using brute force. What defeats me on practical grounds, may be possible for you given a large amount of memory to hold a catalogue of preanalysed patterns.
Our goal are not so different, only the methods are. We are looking for
efficient solution paths. Large preanalysed patterns are clearly not possible without computer support. The type of preanalysed tables I use have the nice property that they remain valid with local updates from subsequent eliminations. So I have a test bed framework for various elimination sequences. Nevertheless any
result should be presented in a human readable form.
David P Bird wrote:Note I use the term 'guessing' where you have used the phrase "assuming the potential targets true and performing a limited number of eliminations". Trial and Error, like assuming a unique solution, is something that you're either prepared to employ or not. For me it's equivalent to cheating at patience. But it's a wide church and there's room for both of us.
I got the impression that the term
guessing usually appears in discussions about distinguishing
guessing from
noguessing, where the latter is regarded as superior. But its just two sides of the same coin with no substantial difference. Any result of guessing + T&E can be transposed into a direct form and vice versa.
This is my comment to your fundamental remarks, the following returns to the topic of this thread. Btw these comments have very little connection to pattern permutations (my other thread).
After analysing a couple of Exocet patterns, I identified a common kernel structure. As I did not follow all Exocet discussions, I can't say if its something really new. The kernel structure is maybe part of a larger class than JExocet.
 Code: Select all
A1==========A2==========A3
  
B1==========B2==========B3
  
  
R1==R2==RX S1==S2==SX T1==T2==TX
  
______________________

TGT
RX NAND SX, RX NAND TX, SX NAND TX
My view on patterns is generally more abstract and similar to Denis view. So I do not refer to
cells etc, but rather to
lines containing the remaining candidates related to a constraint. So A,B,R,S,T can be lines of any type (cell, row, col, box). Exocet seem to consider A,B of cell type and R,S,T of row/col type only, but the above structure works with any types. The index numbers on the lines do
not refer to symbol numbers but to line members. RX,SX,TX denotes one or more candidates.
The pattern kernel consists of 5 base lines. The lines A,B must be of the same type, A must contain 3 candidates, the other 3 or 2. The lines R,S,T must have at least 3 candidates, where one is connected to the target and another one connected to A,B in the way shown in the diagram. The target(s) are false if the Xcandidates are
indirectly linked pairwise (NAND).
This is what I called
rule fragment in a previous post, because the details of the indirect links are left open. So you may have a number of subrules.
The elimination is easy to prove. Assuming TGT = true kills R1+S1+T1. The secondary assumption of RX = true kills SX+TX by NAND, activates S2+T2 and creates a contradiction in A+B. The inverse assumption of RX = false activates R2 and killing A1+B1. A23+B23 are killing S2+T2 with the pair rule, activating SX+TX and contradicting the indirect link. This is sufficient because of the pattern symmetry.
So all patterns containing this kernel delete the target. The JExocet seems to be more special with a second set of base lines X,Y,Z connected to A+B.
To verify such pattern in a PM pracitically, I would
Set the target neighbors R1+R2+R3 = false
Set RX = true and TX = true, subsequent steps must create a contradiction, confirming RX NAND TX.
The same with RX+SX and SX+TX.
A kernel with four (or five) candidates in A,B can be constructed in the same way, adding C (or D). Any subrules need only to assure the NAND terms for verification.
Its obvious that all patterns based on such kernel are "exotic" in the sense prohibiting a classification with Denis rule hierarchy. The pattern kernel contains
inevitable branches that you cannot bypass by braids, gbraids, not even by S2braids.