Web based solver
Moderatoren: Syndicate, Andrew
Re: Web based solver
Hi Robo,
Thanks for the heads up on the pop up boxes, I missed that.
Still, the Canis Major eliminations previously referred to just say that they don't fit into any valid combo of the relevant column. Whilst this is no doubt true, it sounds suspiciously like Trial and Error to me: assume the elimination is True and eventually come to a contradiction in the column (at least one cell has no candidates left).
I come from a Sudoku background, where T&E is not regarded very highly at all. My alternative constructive proofs all come from Slow Thinker's slideshow on solving techniques, or from discussions on Andrew's Extreme forum over the years, so they would be regarded as Standard Toolbox CE's.
Thanks for the heads up on the pop up boxes, I missed that.
Still, the Canis Major eliminations previously referred to just say that they don't fit into any valid combo of the relevant column. Whilst this is no doubt true, it sounds suspiciously like Trial and Error to me: assume the elimination is True and eventually come to a contradiction in the column (at least one cell has no candidates left).
I come from a Sudoku background, where T&E is not regarded very highly at all. My alternative constructive proofs all come from Slow Thinker's slideshow on solving techniques, or from discussions on Andrew's Extreme forum over the years, so they would be regarded as Standard Toolbox CE's.
Re: Web based solver
Hi robo,
the solver might be faster if it starts chains with digits in black cells (after hi/lo decisions). Perhaps you could check that. Thanks in advance
the solver might be faster if it starts chains with digits in black cells (after hi/lo decisions). Perhaps you could check that. Thanks in advance
Re: Web based solver
@Leren: I understand this. In this regard my solver is certainly not yet at the level of yours. I have quite a few algorithms still on my todo list. But as my interest is mainly in the software engineering aspects, I have given higher priority to other features of the solver during the last weeks. More will come
@morl: Thanks, that's an interesting idea that I will certainly try and report back here. It may take some time though, as I still have to finish a larger feature (optimizing the chains) first (see above )
@morl: Thanks, that's an interesting idea that I will certainly try and report back here. It may take some time though, as I still have to finish a larger feature (optimizing the chains) first (see above )
Re: Web based solver
Hi Robo,
I was little short of time last week. So I postponed the detailed answer to your solver discussion to this weekend.
Here some thoughts regarding putting up a solver based on Dancing Links.
0) References
Checkout English Wikipedia for ‘Dancing Links’, ‘Algorithm X’, ‘Exact Cover Problem’, and Sudoku solvers. Most importantly, see the Sudoku Dancing Links paper on D.E. Knuths page. There has also been a Str8ts paper which I sadly couldn’t find any more. Maybe Ben who originally posted can provide you the URL.
Further, check out an existing dancing links implementation on github.
1) Solution Representation
Potential parts of the solution are represented as triples (row, col, num), i.e. elements auf a cube [1 ; 9] x [1 ; 9] x [1 ; 9]. The solution(s) are a subset of all elements of the cube which is subject of retrieval.
2) Board Representation / Initial Clues
Initial clues are handled by selecting the respective triple for the given clue; black cells by removing all corresponding triples.
3) Rules of the Game / Problem Representation
Not every set of triples is a valid solution; solutions have to comply with the rules of the game. One is ‘every cell has to be filled exactly once’, a second ‘there can be only one number X in row Y at maximum’, a third is ‘there cannot be a 5 in a length4 compartment if there is already a 1’ (A1234), … . The last type of rule depends on the geometry. Note that – in opposite to Sudoku – some rules are mandatory (e.g. the fill rule), some are optional (the 15 rule).
The problem of a given Str8ts puzzle is represented as matrix the rows of which are the partial solution candidates and the columns are the rules. An element of the matrix is marked (i.e. value 1) if the selection of a triple would trigger a rule. E.g. the fill(1; 1; X) rule of all 9 triples would have a mark in the respective column. Or (1; 4; 1) … (1; 4; 5) in the 15 rule column. All other elements are zero.
As result, selecting two columns with nonzero entry in the same column as part of the solution would lead a contradiction.
4) Recursive Solution Procedure
The solution process is recursive: a) select any mandatory rule, typically the one with the least candidate triples; b) test all possible candidates; c) check the rules a candidate in b) triggers; d) remove all triples that contradict these rules as well as the columns of the rules; e) repeat recursively with reduced matrix until a solution or a dead end is found.
This is just another form of backtracking although potentially more efficient than starting to fill A1, then A2, … . This kind of approach might be good to check puzzles, but not to solve them as a human would.
5) Dancing Links
Knuth discovered that most work is done selecting a submatrix and undoing that selection. An efficient means to do both is via doublelinked lists. See Dancing Links. The solving process can as well be done – less efficient – with ordinary full matrices.
So far this is – as stated  just an ordinary backtracking solver, which I assume you are only partially interested in. It does just trialanderror. But the backtracking solver can be an extremely efficient backend for a cleverer solver: applying strategies as a human would and potentially also faster than pure backtracking.
6) Solving Strategies in Context of Dancing Links
Several solving strategies have been developed in this forum over the years. In my opinion, none have been proven constructively but all by contradiction. ‘If 5 and 6 would be somewhere different than cell X and Y, this would result an error later on’ (naked double XY56). Similar considerations apply for all other strategies (see UR below).
A way to apply such rules in the context of Dancing Links can be as follows: a) select a suitable set of mandatory rules (here fill X and Y); b) select all triples that are related to these rules (here the candidates in those cells) => submatrix; c) do backtracking on the reduced matrix to find all solutions; d) draw potential conclusions from union and intersection of all retrieved partial solutions (here ‘at most on 5’ and ‘at most one 6’ rules triggered); e) select the generally valid rows and remove the rows that would contradict the triggered rules (here the 5s and 6s in all other cells). If there is no naked double, the rules are only triggered for parts of the solutions and the intersection is thus empty, e.g. nothing to conclude. The list here of things do derive might be incomplete (e.g. accounting rules not triggered at all, solutions in all cases).
Most (all?) known strategies can be derived in this was. The goal in all cases is to eliminate candidates (triples) and to ultimately have trivial rules with only one candidate, i.e. solved cells (triples added to solution).
7) Types of Strategies
There are to my opinion 3 types of strategies, one for each triple index: a) row strategies (basic St8ts strategies); b) corresponding column strategies; c) number strategies (i.e. wings and Settis which are by the way the same anyway…). All strategies can be applied to a full row (all others incl. CE), compartment (range, required digit, etc.), or any subset of cells ((naked) double / triple, …).
Note that in this triple representation a Xwing is the analog of a naked double, the same is true for higher wings. Further it is important to have the possibility to move a rule from optional to mandatory (required digit, singles, Settis / wings). All strategies are just a suitable selection of a submatrix and correct application of the drawn conclusions to the remaining matrix.
8) Incremental Solving
The overall strategy has to be to incrementally draw conclusions from a subset of the puzzle. The simplest approach is to a) process all individual rows; b) all individual columns; c) all digits (wings) separately; d) repeat previous steps; e) do full backtracking if no changes from a full iteration.
A more human like would first test all combinations of 2 cells (naked double), then the compartment, and as last resort the full row (CE).
9) Performance
The underlying Dancing Links structure is extremely efficient. If I remember correctly, subsecond performance has been reported for extremes back then (backtracking). Backtracking on rows is not too expensive: E.g. a row with 2 length4 compartments in an entirely empty puzzle has 3 (where is the 5) x 2 (hi/low) x 4! x 4! = 3456 solutions to be retrieved. I assume this is sufficiently fast.
Guess the key is to find a way to avoid doing the expensive tests and to rather repeat the cheap ones. A further approach might be to only redo those tests that are affected by matrix changes since the last run of the same test.
In general I assume there’s also large potential for multithreading to speedup (e.g. C++ promise/futures working on replicated matrices). But I assume you are rather interested in clientside web technology in which I have not much expertise.
10) Advanced Strategies
In the proposed approach you can also aim to go for more advanced strategies.
For instance, you can do Ywings (and headchains) like this: a) iterate all potential candidates in a given cell; b) do all trivial eliminations; c) check for conclusions (union / intersection) as done for all strategies.
URs are a second example: a) select a given candidate in a cell; b) check if removal of the cell diagonalizes the matrix (i.e. two or more independent submatrixes after reordering of rows and columns); c) solve the small submatrix; d) remove the original candidate under test if the submatrix has multiple solutions.
For most cases, implementing a given strategy is just the suitable selection of the subset of rows and columns. I.e. providing the solver additional strategies is simply to add selection methods.
11) Metrics
I guess there are two metrics needed on top of the basic solver for an advanced solver: a) estimation of expected benefit (removed entries) per runtime for a given strategy; b) rating of complexity of strategies. With both strategies available you can design a solving sequence that might be most efficient or simplest in terms of human rating. If you are trendy enough, you have to use Deep Neuronal Networks
Hope my monologue was not too boring and potentially somehow helpful for your efforts. Let me know if my explanations are poor or in case you have questions.
Best,
CL
I was little short of time last week. So I postponed the detailed answer to your solver discussion to this weekend.
Here some thoughts regarding putting up a solver based on Dancing Links.
0) References
Checkout English Wikipedia for ‘Dancing Links’, ‘Algorithm X’, ‘Exact Cover Problem’, and Sudoku solvers. Most importantly, see the Sudoku Dancing Links paper on D.E. Knuths page. There has also been a Str8ts paper which I sadly couldn’t find any more. Maybe Ben who originally posted can provide you the URL.
Further, check out an existing dancing links implementation on github.
1) Solution Representation
Potential parts of the solution are represented as triples (row, col, num), i.e. elements auf a cube [1 ; 9] x [1 ; 9] x [1 ; 9]. The solution(s) are a subset of all elements of the cube which is subject of retrieval.
2) Board Representation / Initial Clues
Initial clues are handled by selecting the respective triple for the given clue; black cells by removing all corresponding triples.
3) Rules of the Game / Problem Representation
Not every set of triples is a valid solution; solutions have to comply with the rules of the game. One is ‘every cell has to be filled exactly once’, a second ‘there can be only one number X in row Y at maximum’, a third is ‘there cannot be a 5 in a length4 compartment if there is already a 1’ (A1234), … . The last type of rule depends on the geometry. Note that – in opposite to Sudoku – some rules are mandatory (e.g. the fill rule), some are optional (the 15 rule).
The problem of a given Str8ts puzzle is represented as matrix the rows of which are the partial solution candidates and the columns are the rules. An element of the matrix is marked (i.e. value 1) if the selection of a triple would trigger a rule. E.g. the fill(1; 1; X) rule of all 9 triples would have a mark in the respective column. Or (1; 4; 1) … (1; 4; 5) in the 15 rule column. All other elements are zero.
As result, selecting two columns with nonzero entry in the same column as part of the solution would lead a contradiction.
4) Recursive Solution Procedure
The solution process is recursive: a) select any mandatory rule, typically the one with the least candidate triples; b) test all possible candidates; c) check the rules a candidate in b) triggers; d) remove all triples that contradict these rules as well as the columns of the rules; e) repeat recursively with reduced matrix until a solution or a dead end is found.
This is just another form of backtracking although potentially more efficient than starting to fill A1, then A2, … . This kind of approach might be good to check puzzles, but not to solve them as a human would.
5) Dancing Links
Knuth discovered that most work is done selecting a submatrix and undoing that selection. An efficient means to do both is via doublelinked lists. See Dancing Links. The solving process can as well be done – less efficient – with ordinary full matrices.
So far this is – as stated  just an ordinary backtracking solver, which I assume you are only partially interested in. It does just trialanderror. But the backtracking solver can be an extremely efficient backend for a cleverer solver: applying strategies as a human would and potentially also faster than pure backtracking.
6) Solving Strategies in Context of Dancing Links
Several solving strategies have been developed in this forum over the years. In my opinion, none have been proven constructively but all by contradiction. ‘If 5 and 6 would be somewhere different than cell X and Y, this would result an error later on’ (naked double XY56). Similar considerations apply for all other strategies (see UR below).
A way to apply such rules in the context of Dancing Links can be as follows: a) select a suitable set of mandatory rules (here fill X and Y); b) select all triples that are related to these rules (here the candidates in those cells) => submatrix; c) do backtracking on the reduced matrix to find all solutions; d) draw potential conclusions from union and intersection of all retrieved partial solutions (here ‘at most on 5’ and ‘at most one 6’ rules triggered); e) select the generally valid rows and remove the rows that would contradict the triggered rules (here the 5s and 6s in all other cells). If there is no naked double, the rules are only triggered for parts of the solutions and the intersection is thus empty, e.g. nothing to conclude. The list here of things do derive might be incomplete (e.g. accounting rules not triggered at all, solutions in all cases).
Most (all?) known strategies can be derived in this was. The goal in all cases is to eliminate candidates (triples) and to ultimately have trivial rules with only one candidate, i.e. solved cells (triples added to solution).
7) Types of Strategies
There are to my opinion 3 types of strategies, one for each triple index: a) row strategies (basic St8ts strategies); b) corresponding column strategies; c) number strategies (i.e. wings and Settis which are by the way the same anyway…). All strategies can be applied to a full row (all others incl. CE), compartment (range, required digit, etc.), or any subset of cells ((naked) double / triple, …).
Note that in this triple representation a Xwing is the analog of a naked double, the same is true for higher wings. Further it is important to have the possibility to move a rule from optional to mandatory (required digit, singles, Settis / wings). All strategies are just a suitable selection of a submatrix and correct application of the drawn conclusions to the remaining matrix.
8) Incremental Solving
The overall strategy has to be to incrementally draw conclusions from a subset of the puzzle. The simplest approach is to a) process all individual rows; b) all individual columns; c) all digits (wings) separately; d) repeat previous steps; e) do full backtracking if no changes from a full iteration.
A more human like would first test all combinations of 2 cells (naked double), then the compartment, and as last resort the full row (CE).
9) Performance
The underlying Dancing Links structure is extremely efficient. If I remember correctly, subsecond performance has been reported for extremes back then (backtracking). Backtracking on rows is not too expensive: E.g. a row with 2 length4 compartments in an entirely empty puzzle has 3 (where is the 5) x 2 (hi/low) x 4! x 4! = 3456 solutions to be retrieved. I assume this is sufficiently fast.
Guess the key is to find a way to avoid doing the expensive tests and to rather repeat the cheap ones. A further approach might be to only redo those tests that are affected by matrix changes since the last run of the same test.
In general I assume there’s also large potential for multithreading to speedup (e.g. C++ promise/futures working on replicated matrices). But I assume you are rather interested in clientside web technology in which I have not much expertise.
10) Advanced Strategies
In the proposed approach you can also aim to go for more advanced strategies.
For instance, you can do Ywings (and headchains) like this: a) iterate all potential candidates in a given cell; b) do all trivial eliminations; c) check for conclusions (union / intersection) as done for all strategies.
URs are a second example: a) select a given candidate in a cell; b) check if removal of the cell diagonalizes the matrix (i.e. two or more independent submatrixes after reordering of rows and columns); c) solve the small submatrix; d) remove the original candidate under test if the submatrix has multiple solutions.
For most cases, implementing a given strategy is just the suitable selection of the subset of rows and columns. I.e. providing the solver additional strategies is simply to add selection methods.
11) Metrics
I guess there are two metrics needed on top of the basic solver for an advanced solver: a) estimation of expected benefit (removed entries) per runtime for a given strategy; b) rating of complexity of strategies. With both strategies available you can design a solving sequence that might be most efficient or simplest in terms of human rating. If you are trendy enough, you have to use Deep Neuronal Networks
Hope my monologue was not too boring and potentially somehow helpful for your efforts. Let me know if my explanations are poor or in case you have questions.
Best,
CL
Re: Web based solver
Hi CL,
Thanks a lot, that's a lot of material that will take some time to digest.
After a brief scan of Knuth's work, I believe that
Again, thank you for this great compilation.
robo
Thanks a lot, that's a lot of material that will take some time to digest.
After a brief scan of Knuth's work, I believe that
 Since I really like the visualization of the realtime growth of the solutiontree, I need breadthfirst search, while Knuth's Algorithm X is depthfirst.
 Knuth's algorithm has advantages only under memory constraints. For the Str8ts problem and today's computing environment, I have no problems in keeping all states along the solution tree, and even multiple trees to find the best one.
Again, thank you for this great compilation.
robo
Re: Web based solver
1) To my understanding, there is no breadthfirst in AlgorithmX as the major information is only in the leaves of the tree (solution / no solution). The internal nodes just code the way to / the parts of the solution. Yet, you lack knowledge on their relevance as long as you do not know the leaves.
2) Concerning mMemory, you are right in one respect. You can work with a single copy of the matrix instead of having to put multiple copies on the stack with recursive calls. This is not a Problem on modern CPUs. Yet, there is a greater advantage: recursion requires deep copies of a potentially large matrix (roughly proportional to matrix size). This might be relatively expensive. With Dancing Links, entering a recursive function call requires just removal of a few links; returning requires restoration of these few links only.
3) What's more interesting to me than Dancing Links is the representation of the Str8ts pProblem. Links is about computational efficiency only. The matrix however represents the problem extremely compact and in a straight forward way. All possible choices and all implications of a certain decision are stored as simple binary flag. This eases implementation of strategies to my understanding a lot! Maybe Leren, Klaus, etc. can tell you what is their representation of partial solutions, required digits, etc. is...
2) Concerning mMemory, you are right in one respect. You can work with a single copy of the matrix instead of having to put multiple copies on the stack with recursive calls. This is not a Problem on modern CPUs. Yet, there is a greater advantage: recursion requires deep copies of a potentially large matrix (roughly proportional to matrix size). This might be relatively expensive. With Dancing Links, entering a recursive function call requires just removal of a few links; returning requires restoration of these few links only.
3) What's more interesting to me than Dancing Links is the representation of the Str8ts pProblem. Links is about computational efficiency only. The matrix however represents the problem extremely compact and in a straight forward way. All possible choices and all implications of a certain decision are stored as simple binary flag. This eases implementation of strategies to my understanding a lot! Maybe Leren, Klaus, etc. can tell you what is their representation of partial solutions, required digits, etc. is...
Re: Web based solver
Hi C_L,
not quite sure if i really understood what you are describing in your posts above. I never did any theoretical work on solution representation, searches, trees and so on. Did it all on my own from scratch. (by the way, do things like mMemory or pProblem have a special meaning or is it just a nervous finger?).
The triple alone holds very little information. It doesnt know to which compartments it belongs, whether the candidate is a must in its row/column and so on. These are essential things if you want a powerful and efficient Str8tsSolver. Can you formulate this as rules for the triple (the ones you described are very simple and basic)? How would e.g. a compartmentinteractioncheck be done, Setti, ...?
My represention of the puzzle is very humanlike, just as you see it. A structure with 9 rows and columns, each of them has a set of compartments. Then a set of cells, every cell has a unique position in exactly one row, column, rowcompartment and columncompartment. In addition every cell and compartment has a set of candidates. Then a bunch of checks, each of them trying to find candidates, which contradicte one of the rules known to me. if so, the candidate is removed and the whole things starts again. Thats it, all very simple.
Best wishes,
Klaus
not quite sure if i really understood what you are describing in your posts above. I never did any theoretical work on solution representation, searches, trees and so on. Did it all on my own from scratch. (by the way, do things like mMemory or pProblem have a special meaning or is it just a nervous finger?).
The triple alone holds very little information. It doesnt know to which compartments it belongs, whether the candidate is a must in its row/column and so on. These are essential things if you want a powerful and efficient Str8tsSolver. Can you formulate this as rules for the triple (the ones you described are very simple and basic)? How would e.g. a compartmentinteractioncheck be done, Setti, ...?
My represention of the puzzle is very humanlike, just as you see it. A structure with 9 rows and columns, each of them has a set of compartments. Then a set of cells, every cell has a unique position in exactly one row, column, rowcompartment and columncompartment. In addition every cell and compartment has a set of candidates. Then a bunch of checks, each of them trying to find candidates, which contradicte one of the rules known to me. if so, the candidate is removed and the whole things starts again. Thats it, all very simple.
Best wishes,
Klaus

 Beiträge: 2
 Registriert: Montag 19. August 2019, 07:48
Web based solver
I dont see much difference in your endresult and many of the web based MUD systems. They are often open sourced, and very adaptable.
Most MUD systems are a lot more complex than Usurper was ever or ever will be, a totally different game.
So maybe my question to you would be is, Is what you want to do is clone usurper or a clone of a typical MUD system?
As far what Jakobs opinion on this is, I can not even start to guess.
Most MUD systems are a lot more complex than Usurper was ever or ever will be, a totally different game.
So maybe my question to you would be is, Is what you want to do is clone usurper or a clone of a typical MUD system?
As far what Jakobs opinion on this is, I can not even start to guess.
Web based solver
The Schematic page now allows Optional components to be selected, and the calculated resource totals are now done.
Next I will work on the Templated component selection and then the Best available resource from MyResources part. this will be the most complicated part.
I also have a preliminary Inventory page up.
Any feedback so far? Your comments/suggestions will greatly improve this new utility.
Next I will work on the Templated component selection and then the Best available resource from MyResources part. this will be the most complicated part.
I also have a preliminary Inventory page up.
Any feedback so far? Your comments/suggestions will greatly improve this new utility.