Index: branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionGrammar.cs
===================================================================
--- branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionGrammar.cs	(revision 5694)
+++ branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionGrammar.cs	(revision 5695)
@@ -49,7 +49,5 @@
     public int MinimumFunctionArguments {
       get { return minimumFunctionArguments; }
-      set {
-        minimumFunctionArguments = value;
-      }
+      set { minimumFunctionArguments = value; }
     }
     [Storable]
@@ -57,7 +55,5 @@
     public int MaximumFunctionArguments {
       get { return maximumFunctionArguments; }
-      set {
-        maximumFunctionArguments = value;
-      }
+      set { maximumFunctionArguments = value; }
     }
 
@@ -70,6 +66,10 @@
       get { return ProgramRootSymbol; }
     }
+    [Storable(Name = "ProgramRootSymbol")]
+    private ISymbol StorableProgramRootSymbol {
+      get { return programRootSymbol; }
+      set { programRootSymbol = (ProgramRootSymbol)value; }
+    }
 
-    [Storable]
     private StartSymbol startSymbol;
     public StartSymbol StartSymbol {
@@ -79,4 +79,9 @@
       get { return StartSymbol; }
     }
+    [Storable(Name = "StartSymbol")]
+    private ISymbol StorableStartSymbol {
+      get { return startSymbol; }
+      set { startSymbol = (StartSymbol)value; }
+    }
 
     [Storable]
@@ -84,4 +89,9 @@
     protected Defun DefunSymbol {
       get { return defunSymbol; }
+    }
+    [Storable(Name = "DefunSymbol")]
+    private ISymbol StorableDefunSymbol {
+      get { return defunSymbol; }
+      set { defunSymbol = (Defun)value; }
     }
     #endregion
Index: branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionGrammarBase.cs
===================================================================
--- branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionGrammarBase.cs	(revision 5694)
+++ branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionGrammarBase.cs	(revision 5695)
@@ -37,11 +37,31 @@
   public abstract class SymbolicExpressionGrammarBase : NamedItem, ISymbolicExpressionGrammarBase {
     #region properties for separation between implementation and persistence
-
-    //TODO implement storable properties;
-
+    [Storable(Name = "Symbols")]
+    private IEnumerable<ISymbol> StorableSymbols {
+      get { return symbols.Values.ToArray(); }
+      set { symbols = value.ToDictionary(sym => sym.Name); }
+    }
+
+    [Storable(Name = "SymbolSubtreeCount")]
+    private IEnumerable<KeyValuePair<ISymbol, Tuple<int, int>>> StorableSymbolSubtreeCount {
+      get { return symbolSubtreeCount.Select(x => new KeyValuePair<ISymbol, Tuple<int, int>>(GetSymbol(x.Key), x.Value)).ToArray(); }
+      set { symbolSubtreeCount = value.ToDictionary(x => x.Key.Name, x => x.Value); }
+    }
+
+    [Storable(Name = "AllowedChildSymbols")]
+    private IEnumerable<KeyValuePair<ISymbol, IEnumerable<ISymbol>>> StorableAllowedChildSymbols {
+      get { return allowedChildSymbols.Select(x => new KeyValuePair<ISymbol, IEnumerable<ISymbol>>(GetSymbol(x.Key), x.Value.Select(y => GetSymbol(y)))).ToArray(); ; }
+      set { allowedChildSymbols = value.ToDictionary(x => x.Key.Name, x => x.Value.Select(y => y.Name).ToList()); }
+    }
+
+    [Storable(Name = "AllowedChildSymbolsPerIndex")]
+    private IEnumerable<KeyValuePair<Tuple<ISymbol, int>, IEnumerable<ISymbol>>> StorableAllowedChildSymbolsPerIndex {
+      get { return allowedChildSymbolsPerIndex.Select(x => new KeyValuePair<Tuple<ISymbol, int>, IEnumerable<ISymbol>>(Tuple.Create(GetSymbol(x.Key.Item1), x.Key.Item2), x.Value.Select(y => GetSymbol(y)))).ToArray(); }
+      set { allowedChildSymbolsPerIndex = value.ToDictionary(x => Tuple.Create(x.Key.Item1.Name, x.Key.Item2), x => x.Value.Select(y => y.Name).ToList()); }
+    }
     #endregion
 
     protected Dictionary<string, ISymbol> symbols;
-    protected Dictionary<string, Tuple<int, int>> symbolSubTreeCount;
+    protected Dictionary<string, Tuple<int, int>> symbolSubtreeCount;
     protected Dictionary<string, List<string>> allowedChildSymbols;
     protected Dictionary<Tuple<string, int>, List<string>> allowedChildSymbolsPerIndex;
@@ -67,5 +87,5 @@
       cachedMinExpressionDepth = new Dictionary<string, int>();
 
-      symbolSubTreeCount = new Dictionary<string, Tuple<int, int>>(original.symbolSubTreeCount);
+      symbolSubtreeCount = new Dictionary<string, Tuple<int, int>>(original.symbolSubtreeCount);
       symbols = new Dictionary<string, ISymbol>(original.symbols);
 
@@ -86,5 +106,5 @@
 
       symbols = new Dictionary<string, ISymbol>();
-      symbolSubTreeCount = new Dictionary<string, Tuple<int, int>>();
+      symbolSubtreeCount = new Dictionary<string, Tuple<int, int>>();
       allowedChildSymbols = new Dictionary<string, List<string>>();
       allowedChildSymbolsPerIndex = new Dictionary<Tuple<string, int>, List<string>>();
@@ -95,5 +115,5 @@
       if (ContainsSymbol(symbol)) throw new ArgumentException("Symbol " + symbol + " is already defined.");
       symbols.Add(symbol.Name, symbol);
-      symbolSubTreeCount.Add(symbol.Name, Tuple.Create(0, 0));
+      symbolSubtreeCount.Add(symbol.Name, Tuple.Create(0, 0));
       ClearCaches();
     }
@@ -104,5 +124,5 @@
       for (int i = 0; i < GetMaximumSubtreeCount(symbol); i++)
         allowedChildSymbolsPerIndex.Remove(Tuple.Create(symbol.Name, i));
-      symbolSubTreeCount.Remove(symbol.Name);
+      symbolSubtreeCount.Remove(symbol.Name);
 
 
@@ -165,5 +185,5 @@
       }
 
-      symbolSubTreeCount[symbol.Name] = Tuple.Create(minimumSubtreeCount, maximumSubtreeCount);
+      symbolSubtreeCount[symbol.Name] = Tuple.Create(minimumSubtreeCount, maximumSubtreeCount);
       ClearCaches();
     }
@@ -217,8 +237,8 @@
 
     public virtual int GetMinimumSubtreeCount(ISymbol symbol) {
-      return symbolSubTreeCount[symbol.Name].Item1;
+      return symbolSubtreeCount[symbol.Name].Item1;
     }
     public virtual int GetMaximumSubtreeCount(ISymbol symbol) {
-      return symbolSubTreeCount[symbol.Name].Item2;
+      return symbolSubtreeCount[symbol.Name].Item2;
     }
 
