TODO

- Look closely at Generate allowed neighbors. Can it be made faster?
- Look closely at how we generate permutations, especially classical case, can it be made faster?
- If cover verification fails, add a constraint to the exact cover, find a new cover, and repeat
- When verifying a cover, generate bit strings for all rules that had the same bit string, and try to glue again. Possibly consider other options.
- Generate rules more efficiently.
    - Support bound on number of non-empty boxes.
    - NEW IDEA: When classical=True:
        - When backtracking to generate rules, check if partial generating rule creates disallowed permutations
        - In a DP kind of way, reuse results for smaller grid sizes
- Framework for tests.
- The XX-overlay rule for Av(123) also comes up for Av(231)
- Can we order the output of the exact cover by the number of rules glued?
- Make a general Settings class to simplify function interfaces
- Make a class that holds perm_prop, perm_bound, etc. and does everything that relates to these properties
    - Should include an is_classical flag, which would turn on classical-specific optimizations
- Use Length0PermutationSet() instead of None for the empty permutation


DONE:
- Preprocess binary strings. Don't do set cover over the same binary string many times. (done in new algorithm)
- Implement Algorithm X for exact cover. DONE!
- We can't seem to be able to do perm_prop = lambda p: p.avoids([1])
  WE DO NOW!
- I get maximum recursion depth exceeded when working with classical
  patterns of length 4. NOT ANYMORE!
- In some cases the exact cover algorithm is slowing things down
  (Happens rarely)
- Rewrite OrderedSetPartitions without all the sets. Benchmark and see if it is faster. (IT WAS!!)
- When we search for 1x1 rules for Av(231) we only get the rule |I| but should also get |Av(231)|
- Generate_of_length: Don't generate rules where the smallest generated permutation is > perm_bound (so perm_bound will now part of the cache key)
- Cache: when saving permutation sets, save identifiers instead of the sets themselves
- Make taylor_dag faster:
    - Generate avoiders of input patterns instead of brute force finding them
- Create the verification permutations when you need them, do the verification length by length (and ask if we should go higher)
    - First generate stuff by using the found cover and check for perm_prop and overlap.
    - If the previous step is ok, then we generate the permutations from the
      input (or in some way get the enumeration) and check that everything was
      generated in the previous step.
- Throw Av(12,21) out of DAG when remove=False, or more generally:
    - Have an option (defaulted to True) that throws Av(increasing, decreasing) out of the DAG