1 files changed, 26 insertions, 1 deletions

diff --git a/TODO/2.1.md b/TODO/2.1.md
index 92e4555..d65eb93 100644
--- a/TODO/2.1.md
+++ b/TODO/2.1.md
@@ -1,5 +1,31 @@
 # TODO-list for version 2.1 (or is it 3.0 at this point?)
 
+## Alg and moveset changes (prerequisite for solve.h)
+
+### moveset.h
+* split off from alg.h
+
+### alg.h
+* There is a (future) bug in the way the solver checks if a move can
+be appended (allowed_next and similar): the last two moves are not enough.
+* Example: using QTM we have last 3 moves U U D. Considering only last 2,
+U could be appended, but it cannot (cancel to U').
+* Solution: the per-moveset bool allowed_next() should take an alg as
+parameter. There are going to be basically two versions, one for QTM and
+one for HTM (but more may be added).
+* Alg should be extended to remember the list of moves on inverse / normal
+separately (without looping over moves).
+* Maybe another parameter to know if it can assume there has not been
+any double switching, i.e. if the last moves are the only ones to
+be checked and there is no need to go back further (e.g. if alg is
+U (... stuff on inverse ...) D I don't want to have to check back
+to the U, but in practice we can often assume this does not happen).
+* Then we can remove last and lastinv from dfsdata.
+* move also can_niss to alg.h
+* the check for the order of the moves (to avoid counting L R and R L as
+different) can be made separately. Maybe add a "compare" function for moves,
+such that non-commuting moves are not comparable (return -1 0 1).
+
 ## Rework solver
 
 * The architecture is the following: solve.h contains a solve() public
@@ -24,7 +50,6 @@ necessary). Maybe cleanup solveoptions too (e.g. threads not necessary).
 * solve.h depends only on moves (dependency on step and trans is removed).
 * preparation step should be reworked, maybe removed or delegated to the
 specific implementations.
-* allowed_moves and cancel_niss are moved to move.h.
 * All dfs stuff in the same function. Maybe remove also solvestop.
 * Move two-step solve to a different module