Index: /branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/GrammarEnumeration/Grammar.cs
===================================================================
--- /branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/GrammarEnumeration/Grammar.cs	(revision 15974)
+++ /branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/GrammarEnumeration/Grammar.cs	(revision 15975)
@@ -24,5 +24,5 @@
     public Symbol StartSymbol { get; private set; }
 
-    public Hasher<int> Hasher { get; }
+    public Hasher<int> Hasher { get; private set; }
 
     #region Symbols
@@ -77,4 +77,9 @@
     public Grammar(string[] variables) : this(variables, Enum.GetValues(typeof(GrammarRule)).Cast<GrammarRule>()) { }
 
+    [StorableConstructor]
+    protected Grammar(bool deserializing) {
+      InitTreeParser();
+    }
+
     protected Grammar(Grammar original, Cloner cloner) : base(original, cloner) {
       infixExpressionFormatter = cloner.Clone(original.infixExpressionFormatter);
@@ -83,23 +88,23 @@
       VarTerminals = original.VarTerminals.Select(cloner.Clone).ToList();
 
-      Var = cloner.Clone(original.Var);
-      Expr = cloner.Clone(original.Expr);
-      Term = cloner.Clone(original.Term);
-      Factor = cloner.Clone(original.Factor);
-      LogFactor = cloner.Clone(original.LogFactor);
-      ExpFactor = cloner.Clone(original.ExpFactor);
-      SinFactor = cloner.Clone(original.SinFactor);
-      SimpleExpr = cloner.Clone(original.SimpleExpr);
-      SimpleTerm = cloner.Clone(original.SimpleTerm);
-      InvExpr = cloner.Clone(original.InvExpr);
-      InvTerm = cloner.Clone(original.InvTerm);
-
-      Addition = cloner.Clone(original.Addition);
-      Multiplication = cloner.Clone(original.Multiplication);
-      Log = cloner.Clone(original.Log);
-      Exp = cloner.Clone(original.Exp);
-      Sin = cloner.Clone(original.Sin);
-      Inv = cloner.Clone(original.Inv);
-      Const = cloner.Clone(original.Const);
+      Var = (NonterminalSymbol)cloner.Clone(original.Var);
+      Expr = (NonterminalSymbol)cloner.Clone(original.Expr);
+      Term = (NonterminalSymbol)cloner.Clone(original.Term);
+      Factor = (NonterminalSymbol)cloner.Clone(original.Factor);
+      LogFactor = (NonterminalSymbol)cloner.Clone(original.LogFactor);
+      ExpFactor = (NonterminalSymbol)cloner.Clone(original.ExpFactor);
+      SinFactor = (NonterminalSymbol)cloner.Clone(original.SinFactor);
+      SimpleExpr = (NonterminalSymbol)cloner.Clone(original.SimpleExpr);
+      SimpleTerm = (NonterminalSymbol)cloner.Clone(original.SimpleTerm);
+      InvExpr = (NonterminalSymbol)cloner.Clone(original.InvExpr);
+      InvTerm = (NonterminalSymbol)cloner.Clone(original.InvTerm);
+
+      Addition = (TerminalSymbol)cloner.Clone(original.Addition);
+      Multiplication = (TerminalSymbol)cloner.Clone(original.Multiplication);
+      Log = (TerminalSymbol)cloner.Clone(original.Log);
+      Exp = (TerminalSymbol)cloner.Clone(original.Exp);
+      Sin = (TerminalSymbol)cloner.Clone(original.Sin);
+      Inv = (TerminalSymbol)cloner.Clone(original.Inv);
+      Const = (TerminalSymbol)cloner.Clone(original.Const);
 
       StartSymbol = Expr;
@@ -240,4 +245,5 @@
     public double EvaluatePhrase(SymbolString s, IRegressionProblemData problemData, bool optimizeConstants) {
       SymbolicExpressionTree tree = ParseSymbolicExpressionTree(s);
+
       return RSquaredEvaluator.Evaluate(problemData, tree, optimizeConstants);
     }
Index: /branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/GrammarEnumeration/GrammarEnumerationAlgorithm.cs
===================================================================
--- /branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/GrammarEnumeration/GrammarEnumerationAlgorithm.cs	(revision 15974)
+++ /branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/GrammarEnumeration/GrammarEnumerationAlgorithm.cs	(revision 15975)
@@ -52,6 +52,7 @@
     }
 
-    protected double VariableImportanceWeight {
+    public double VariableImportanceWeight {
       get { return VariableImportanceWeightParameter.Value.Value; }
+      set { VariableImportanceWeightParameter.Value.Value = value; }
     }
 
@@ -133,4 +134,5 @@
     }
 
+    [Storable]
     public SymbolString BestTrainingSentence { get; set; }     // Currently set in RSquaredEvaluator: quite hacky, but makes testing much easier for now...
     #endregion
@@ -144,9 +146,4 @@
     [Storable]
     internal SearchDataStore OpenPhrases { get; private set; }           // Stack/Queue/etc. for fetching the next node in the search tree.  
-
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-      variableImportance = CalculateVariableImportances();
-    }
 
     #region execution stats
@@ -162,4 +159,5 @@
     #endregion
 
+    [Storable]
     public Grammar Grammar { get; private set; }
 
@@ -168,4 +166,7 @@
       return new GrammarEnumerationAlgorithm(this, cloner);
     }
+
+    [StorableConstructor]
+    protected GrammarEnumerationAlgorithm(bool deserializing) : base(deserializing) { }
 
     public GrammarEnumerationAlgorithm() {
@@ -237,4 +238,5 @@
     #endregion
 
+    [Storable]
     private Dictionary<VariableTerminalSymbol, double> variableImportance;
 
@@ -250,8 +252,10 @@
       OpenPhrases = new SearchDataStore(SearchDataStructure, SearchDataStructureSize, SearchCacheSize); // Select search strategy
 
+      CalculateVariableImportances();
+
       base.Prepare(); // this actually clears the results which will get reinitialized on Run()
     }
 
-    private Dictionary<VariableTerminalSymbol, double> CalculateVariableImportances() {
+    private void CalculateVariableImportances() {
       variableImportance = new Dictionary<VariableTerminalSymbol, double>();
 
@@ -271,5 +275,4 @@
         variableImportance[varSym] = rfImpact.Item2 / sum;
       }
-      return variableImportance;
     }
 
@@ -277,5 +280,4 @@
       // do not reinitialize the algorithm if we're resuming from pause
       if (previousExecutionState != ExecutionState.Paused) {
-        CalculateVariableImportances();
         InitResults();
         var phrase0 = new SymbolString(new[] { Grammar.StartSymbol });
Index: /branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/GrammarEnumeration/Symbol.cs
===================================================================
--- /branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/GrammarEnumeration/Symbol.cs	(revision 15974)
+++ /branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/GrammarEnumeration/Symbol.cs	(revision 15975)
@@ -1,4 +1,6 @@
 ﻿using System;
+using System.Collections;
 using System.Collections.Generic;
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -101,23 +103,31 @@
 
   [StorableClass]
-  public class Production : List<Symbol>, IDeepCloneable {
+  public class Production : DeepCloneable, IList<Symbol> {
+    [Storable]
+    private List<Symbol> symbols;
 
-    public Production(params Symbol[] symbols) : base(symbols) { }
+    public int Count { get { return symbols.Count; } }
 
-    public Production(IEnumerable<Symbol> symbols) : base(symbols) { }
+    public bool IsReadOnly => throw new NotImplementedException();
+
+    public Symbol this[int index] { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+
+    public Production(params Symbol[] symbols) {
+      this.symbols = symbols.ToList();
+    }
+
+    public Production(IEnumerable<Symbol> symbols) {
+      this.symbols = symbols.ToList();
+    }
 
     [StorableConstructor]
     protected Production(bool deserializing) { }
 
-    protected Production(Production original, Cloner cloner) : this(original) {
-      cloner.RegisterClonedObject(original, this);
+    protected Production(Production original, Cloner cloner) {
+      symbols = original.symbols.Select(cloner.Clone).ToList();
     }
 
-    public IDeepCloneable Clone(Cloner cloner) {
+    public override IDeepCloneable Clone(Cloner cloner) {
       return new Production(this, cloner);
-    }
-
-    public object Clone() {
-      return Clone(new Cloner());
     }
 
@@ -125,4 +135,50 @@
       return string.Join(" ", this);
     }
+
+    #region IList<Symbol> methods
+    public IEnumerator<Symbol> GetEnumerator() {
+      return symbols.GetEnumerator();
+    }
+
+    IEnumerator IEnumerable.GetEnumerator() {
+      return GetEnumerator();
+    }
+
+    public int IndexOf(Symbol item) {
+      return symbols.IndexOf(item);
+    }
+
+    public void Insert(int index, Symbol item) {
+      symbols.Insert(index, item);
+    }
+
+    public void RemoveAt(int index) {
+      symbols.RemoveAt(index);
+    }
+
+    public void Add(Symbol item) {
+      symbols.Add(item);
+    }
+
+    public void Clear() {
+      symbols.Clear();
+    }
+
+    public bool Contains(Symbol item) {
+      return symbols.Contains(item);
+    }
+
+    public void CopyTo(Symbol[] array, int arrayIndex) {
+      symbols.CopyTo(array, arrayIndex);
+    }
+
+    public void CopyTo(int index, Symbol[] array, int arrayIndex, int count) {
+      symbols.CopyTo(index, array, arrayIndex, count);
+    }
+
+    public bool Remove(Symbol item) {
+      return symbols.Remove(item);
+    }
+    #endregion
   }
 }
Index: /branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/Hashing/Hasher.cs
===================================================================
--- /branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/Hashing/Hasher.cs	(revision 15974)
+++ /branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/Hashing/Hasher.cs	(revision 15975)
@@ -17,5 +17,6 @@
     }
 
-    protected Grammar Grammar { get; }
+    [Storable]
+    protected Grammar Grammar { get; private set; }
 
     protected abstract THashType AggregateHashes(Symbol operatorSym, IList<THashType> hashes);
