0 Memory accounting: the current mechanism for memory limiting/accounting
  does not seem to work properly

1 Scoring all the occurrences, including learned (dynamic), in heuristics.
  Make a (compile time?) option available so that the user can choose
  to score dynamic occurrences of propositions (occurrences in learned 
  clauses) as well as static ones:
     - in JW, 2JW, Moms, Boehm, the loop that cycles through
       propositions should inspect dynamic occurrences: now it
       inspects static occurrences only;
     - in Sato, when using the shortest-non-Horn-first schema, the
       index that holds non-Horn clauses should reference dynamic
       non-Horn clauses as well as static ones: now it references 
       static ones only;
     - in Satz and Relsat the loop that assesses the number of
       occurrences should include dynamic occurrences: now it includes
       static ones only.
  Unit-based heuristics (Unitie) and unit-based parts of Satz and
  Relsat calculate a score that encloses propagations on learned
  clauses: it is in the nature of these heuristics and it cannot be
  limited to static ones.

2 Learning on failed literals in unit-based heuristics; Satz and
  Unitie get a reason for the failed literals that they report, but no
  learning occurs. Relsat reports a failed literal as a split with the
  very same sign: learning happens via the usual mechanism which is 
  correct but inefficient. Learning can probably be included in the
  failed literal detection mechanism.
 
3 Model variables for Relsat and Sato. Enable some kind of mechanism
  to exploit model variables in Relsat and Sato heuristics. Currently,
  JW, 2JW, Moms, Boehm and Unitie implement restriction of splitting
  to model variables. Satz features a more flexible schema: pure
  literal, PROP41 and PROP31 on all the variables and PROP0 on model
  variables only.

4 Implement restriction as well as preference on model variables.
  Currently, only Satz features something in this spirit...
  
5 Pure literal with learning: scoring all the occurrences (see 1)
  enables a sound (but not complete) version of the pure literal rule.
  Investigate the possibility of a more general approach.

6 Compact reallocation of clauses and propositions
  When accessing propositions and clauses page faults may occur due a
  big relative "distance" of the allocated elements: the phenomenon is
  worsened by reallocations used to enlarge indexes (i.e., in
  learning). One possible solution would be to reallocate, at least,
  (i) a proposition and the list of its occurrences, and (ii) a clause
  and the list of its literals in a compact way.

7 Optimized version of ExtendProp (resolution before subsumption)
  Each time a dead end is reached it is useless to do the clause
  subsumptions: since there are exponentially many dead ends, avoiding
  subsumptions in this case might give a performance boost.

8 Preprocessing
  Various kinds of preprocessing:
          - lookahead: pure literals, unit subsumptions, binary subsumptions
          - resolution: tail resolution, k-literals, adding small resolvents
          - subsumption
          - failed literals
          - more

9 Restart
  Implement search cut off and restart. Add noise to heuristics:
  currently only Relsat features a noisy heuristic.

10 Fix functions high level comments (Synopsis, Description and SeeAlso)





