I discovered Sudoku less than two weeks ago. The main problem in solving such puzzles is usually that you have to keep track of many things and make sure you do not make any careless errors. This does not appeal to me. However, as a retired computer scientist, the technical problem of programing a Problem Solver appealed to me, especially as two possible algorithms immediately occurred to me. (I believe these were the two 'logical' algorithms that occurred to your mathematician.)

What we have is a matrix of three sets of nine nine-cell vectors (box, line, and column) which overlap since, as defined, there are only 81 total cells, with each cell having a representation in each of the three vector sets.

The program starts by placing a "123456789" in each cell of the matrix.

Algorithm 1:

For each nonsingleton cell of the matrix, the program reduces its original set of numbers by any unique singletons in that cell's box, line, and column vectors. This is an iterative process which does not complete until no more cells 'reduce' to singleton cells.

Algorithm 2:

For each nonsingleton cell of the matrix, the program checks that there are duplicates for every remaining number in that cell for each box, line, and column vector. If it finds any number in a cell which is unique to any of that cell's vectors, it forces that cell to that number. Whenever a cell is forced to a singleton, we redo Algorithm 1.

This approach solved all of the easy and (so far) all of the medium puzzles I have encountered. It does not work for the "hard" ones.

I have a third algorithm which has been tested (but not yet programed). Unfortunately for "purity," it is a "trial and error" approach, which are shunned alike by "purists," mathematicians, and computer scientists-- they are not "elegant."

Algorithm 3:

Look for dupleton cells. Having found one, proceed only if there is another dupleton in that cell's vector set which matches at least one of its numbers. If so, force the cell to that number and redo Algorithms 1 and 2 until there are no more changes. If we have a solution, fine. Otherwise, we try the second number for the cell (if it passes the 'nonuniqueness test'), or go on to the next dupleton. This has solved the "hard ones" I've tried so far.

However, I recogize that this cannot be proved to produce a solution. In anticipation, I am working on a generalization of Alg-3 (e.g., a 'multi-pass' trial and error), or Alg-4 (no ideas yet).