Index: /branches/DataAnalysis Refactoring/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearDiscriminantAnalysis.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearDiscriminantAnalysis.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearDiscriminantAnalysis.cs	(revision 5733)
@@ -90,7 +90,7 @@
       ISymbolicExpressionTree tree = new SymbolicExpressionTree(new ProgramRootSymbol().CreateTreeNode());
       ISymbolicExpressionTreeNode startNode = new StartSymbol().CreateTreeNode();
-      tree.Root.AddSubTree(startNode);
+      tree.Root.AddSubtree(startNode);
       ISymbolicExpressionTreeNode addition = new Addition().CreateTreeNode();
-      startNode.AddSubTree(addition);
+      startNode.AddSubtree(addition);
 
       int col = 0;
@@ -99,5 +99,5 @@
         vNode.VariableName = column;
         vNode.Weight = w[col];
-        addition.AddSubTree(vNode);
+        addition.AddSubtree(vNode);
         col++;
       }
@@ -105,5 +105,5 @@
       ConstantTreeNode cNode = (ConstantTreeNode)new Constant().CreateTreeNode();
       cNode.Value = w[w.Length - 1];
-      addition.AddSubTree(cNode);
+      addition.AddSubtree(cNode);
 
 
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearRegression.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearRegression.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearRegression.cs	(revision 5733)
@@ -94,7 +94,7 @@
       ISymbolicExpressionTree tree = new SymbolicExpressionTree(new ProgramRootSymbol().CreateTreeNode());
       ISymbolicExpressionTreeNode startNode = new StartSymbol().CreateTreeNode();
-      tree.Root.AddSubTree(startNode);
+      tree.Root.AddSubtree(startNode);
       ISymbolicExpressionTreeNode addition = new Addition().CreateTreeNode();
-      startNode.AddSubTree(addition);
+      startNode.AddSubtree(addition);
 
       int col = 0;
@@ -103,5 +103,5 @@
         vNode.VariableName = column;
         vNode.Weight = coefficients[col];
-        addition.AddSubTree(vNode);
+        addition.AddSubtree(vNode);
         col++;
       }
@@ -109,5 +109,5 @@
       ConstantTreeNode cNode = (ConstantTreeNode)new Constant().CreateTreeNode();
       cNode.Value = coefficients[coefficients.Length - 1];
-      addition.AddSubTree(cNode);
+      addition.AddSubtree(cNode);
 
       SymbolicRegressionSolution solution = new SymbolicRegressionSolution(new SymbolicRegressionModel(tree, new SymbolicDataAnalysisExpressionTreeInterpreter()), problemData);
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views/3.4/SymbolicExpressionTreeChart.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views/3.4/SymbolicExpressionTreeChart.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views/3.4/SymbolicExpressionTreeChart.cs	(revision 5733)
@@ -263,5 +263,5 @@
 
       //draw terminal node
-      if (node.SubTrees.Count() == 0) {
+      if (node.Subtrees.Count() == 0) {
         graphics.FillRectangle(nodeFillBrush, visualTreeNode.X, visualTreeNode.Y, visualTreeNode.Width, visualTreeNode.Height);
         graphics.DrawRectangle(nodeLinePen, visualTreeNode.X, visualTreeNode.Y, visualTreeNode.Width, visualTreeNode.Height);
@@ -281,9 +281,9 @@
       //calculate areas for the subtrees according to their tree size and call drawFunctionTree
       Point connectFrom = new Point(visualTreeNode.X + visualTreeNode.Width / 2, visualTreeNode.Y + visualTreeNode.Height);
-      int[] xBoundaries = new int[node.SubTrees.Count() + 1];
+      int[] xBoundaries = new int[node.Subtrees.Count() + 1];
       xBoundaries[0] = x;
-      for (int i = 0; i < node.SubTrees.Count(); i++) {
-        xBoundaries[i + 1] = (int)(xBoundaries[i] + (width * (double)node.SubTrees.ElementAt(i).GetLength()) / (node.GetLength() - 1));
-        DrawFunctionTree(node.SubTrees.ElementAt(i), graphics, xBoundaries[i], y + height,
+      for (int i = 0; i < node.Subtrees.Count(); i++) {
+        xBoundaries[i + 1] = (int)(xBoundaries[i] + (width * (double)node.Subtrees.ElementAt(i).GetLength()) / (node.GetLength() - 1));
+        DrawFunctionTree(node.Subtrees.ElementAt(i), graphics, xBoundaries[i], y + height,
           xBoundaries[i + 1] - xBoundaries[i], height, connectFrom);
       }
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/ArgumentCreater.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/ArgumentCreater.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/ArgumentCreater.cs	(revision 5733)
@@ -124,6 +124,6 @@
       // the branch at the cut point is to be replaced by a new argument node
       var cutPoints = (from node in defunBranch.IterateNodesPrefix()
-                       where node.SubTrees.Count() > 0
-                       from subtree in node.SubTrees
+                       where node.Subtrees.Count() > 0
+                       from subtree in node.Subtrees
                        select new CutPoint(node, subtree)).ToList();
 
@@ -134,6 +134,6 @@
       // replace the branch at the cut point with an argument node
       var replacedBranch = selectedCutPoint.Child;
-      selectedCutPoint.Parent.RemoveSubTree(selectedCutPoint.ChildIndex);
-      selectedCutPoint.Parent.InsertSubTree(selectedCutPoint.ChildIndex, newArgumentNode);
+      selectedCutPoint.Parent.RemoveSubtree(selectedCutPoint.ChildIndex);
+      selectedCutPoint.Parent.InsertSubtree(selectedCutPoint.ChildIndex, newArgumentNode);
 
       // find all old invocations of the selected ADF and attach a cloned version of the replaced branch (with all argument-nodes expanded)
@@ -141,5 +141,5 @@
       var invocationNodes = (from node in tree.IterateNodesPostfix().OfType<InvokeFunctionTreeNode>()
                              where node.Symbol.FunctionName == defunBranch.FunctionName
-                             where node.SubTrees.Count() == defunBranch.NumberOfArguments
+                             where node.Subtrees.Count() == defunBranch.NumberOfArguments
                              select node).ToList();
       // do this repeatedly until no matching invocations are found      
@@ -148,9 +148,9 @@
         foreach (var invocationNode in invocationNodes) {
           // check that the invocation node really has the correct number of arguments
-          if (invocationNode.SubTrees.Count() != defunBranch.NumberOfArguments) throw new InvalidOperationException();
+          if (invocationNode.Subtrees.Count() != defunBranch.NumberOfArguments) throw new InvalidOperationException();
           // append a new argument branch after expanding all argument nodes
           var clonedBranch = (ISymbolicExpressionTreeNode)replacedBranch.Clone();
-          clonedBranch = ReplaceArgumentsInBranch(clonedBranch, invocationNode.SubTrees);
-          invocationNode.InsertSubTree(newArgumentNode.Symbol.ArgumentIndex, clonedBranch);
+          clonedBranch = ReplaceArgumentsInBranch(clonedBranch, invocationNode.Subtrees);
+          invocationNode.InsertSubtree(newArgumentNode.Symbol.ArgumentIndex, clonedBranch);
           newlyAddedBranches.Add(clonedBranch);
         }
@@ -159,5 +159,5 @@
                            from node in newlyAddedBranch.IterateNodesPostfix().OfType<InvokeFunctionTreeNode>()
                            where node.Symbol.FunctionName == defunBranch.FunctionName
-                           where node.SubTrees.Count() == defunBranch.NumberOfArguments
+                           where node.Subtrees.Count() == defunBranch.NumberOfArguments
                            select node).ToList();
       }
@@ -173,5 +173,5 @@
           defunBranch.Grammar.AddAllowedChildSymbol(symb, newArgumentNode.Symbol, i);
         }
-      foreach (var subtree in tree.Root.SubTrees) {
+      foreach (var subtree in tree.Root.Subtrees) {
         // when the changed function is known in the branch then update the number of arguments
         var matchingSymbol = subtree.Grammar.Symbols.OfType<InvokeFunction>().Where(s => s.FunctionName == defunBranch.FunctionName).SingleOrDefault();
@@ -196,8 +196,8 @@
       } else {
         // call recursively for all subtree
-        List<ISymbolicExpressionTreeNode> subtrees = new List<ISymbolicExpressionTreeNode>(branch.SubTrees);
-        while (branch.SubTrees.Count() > 0) branch.RemoveSubTree(0);
+        List<ISymbolicExpressionTreeNode> subtrees = new List<ISymbolicExpressionTreeNode>(branch.Subtrees);
+        while (branch.Subtrees.Count() > 0) branch.RemoveSubtree(0);
         foreach (var subtree in subtrees) {
-          branch.AddSubTree(ReplaceArgumentsInBranch(subtree, argumentTrees));
+          branch.AddSubtree(ReplaceArgumentsInBranch(subtree, argumentTrees));
         }
         return branch;
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/ArgumentDeleter.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/ArgumentDeleter.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/ArgumentDeleter.cs	(revision 5733)
@@ -71,5 +71,5 @@
                              select node).ToList();
       foreach (var invokeNode in invocationNodes) {
-        invokeNode.RemoveSubTree(removedArgument);
+        invokeNode.RemoveSubtree(removedArgument);
       }
 
@@ -81,5 +81,5 @@
       selectedDefunBranch.NumberOfArguments--;
       // reduce arity in known functions of all root branches
-      foreach (var subtree in symbolicExpressionTree.Root.SubTrees) {
+      foreach (var subtree in symbolicExpressionTree.Root.Subtrees) {
         var matchingInvokeSymbol = subtree.Grammar.Symbols.OfType<InvokeFunction>().Where(s => s.FunctionName == selectedDefunBranch.FunctionName).SingleOrDefault();
         if (matchingInvokeSymbol != null) {
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/ArgumentDuplicater.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/ArgumentDuplicater.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/ArgumentDuplicater.cs	(revision 5733)
@@ -86,5 +86,5 @@
       var invocationNodes = (from node in symbolicExpressionTree.IterateNodesPrefix().OfType<InvokeFunctionTreeNode>()
                              where node.Symbol.FunctionName == selectedDefunBranch.FunctionName
-                             where node.SubTrees.Count() == selectedDefunBranch.NumberOfArguments
+                             where node.Subtrees.Count() == selectedDefunBranch.NumberOfArguments
                              select node).ToList();
       // do this repeatedly until no matching invocations are found      
@@ -93,8 +93,8 @@
         foreach (var invokeNode in invocationNodes) {
           // check that the invocation node really has the correct number of arguments
-          if (invokeNode.SubTrees.Count() != selectedDefunBranch.NumberOfArguments) throw new InvalidOperationException();
-          var argumentBranch = invokeNode.GetSubTree(selectedArgumentSymbol.ArgumentIndex);
+          if (invokeNode.Subtrees.Count() != selectedDefunBranch.NumberOfArguments) throw new InvalidOperationException();
+          var argumentBranch = invokeNode.GetSubtree(selectedArgumentSymbol.ArgumentIndex);
           var clonedArgumentBranch = (ISymbolicExpressionTreeNode)argumentBranch.Clone();
-          invokeNode.InsertSubTree(newArgumentIndex, clonedArgumentBranch);
+          invokeNode.InsertSubtree(newArgumentIndex, clonedArgumentBranch);
           newlyAddedBranches.Add(clonedArgumentBranch);
         }
@@ -102,5 +102,5 @@
                            from node in newlyAddedBranch.IterateNodesPrefix().OfType<InvokeFunctionTreeNode>()
                            where node.Symbol.FunctionName == selectedDefunBranch.FunctionName
-                           where node.SubTrees.Count() == selectedDefunBranch.NumberOfArguments
+                           where node.Subtrees.Count() == selectedDefunBranch.NumberOfArguments
                            select node).ToList();
       }
@@ -116,5 +116,5 @@
 
       // increase the arity of the changed ADF in all branches that can use this ADF
-      foreach (var subtree in symbolicExpressionTree.Root.SubTrees) {
+      foreach (var subtree in symbolicExpressionTree.Root.Subtrees) {
         var matchingInvokeSymbol = (from symb in subtree.Grammar.Symbols.OfType<InvokeFunction>()
                                     where symb.FunctionName == selectedDefunBranch.FunctionName
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/SubroutineCreater.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/SubroutineCreater.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/SubroutineCreater.cs	(revision 5733)
@@ -95,5 +95,5 @@
 
       // select a random body (either the result producing branch or an ADF branch)
-      var bodies = from node in symbolicExpressionTree.Root.SubTrees
+      var bodies = from node in symbolicExpressionTree.Root.Subtrees
                    select new { Tree = node, Length = node.GetLength() };
       var totalNumberOfBodyNodes = bodies.Select(x => x.Length).Sum();
@@ -111,5 +111,5 @@
       // select a random cut point in the selected branch
       var allCutPoints = (from parent in selectedBody.IterateNodesPrefix()
-                          from subtree in parent.SubTrees
+                          from subtree in parent.Subtrees
                           select new CutPoint(parent, subtree)).ToList();
       if (allCutPoints.Count() == 0)
@@ -122,19 +122,19 @@
       ISymbolicExpressionTreeNode functionBody = selectedCutPoint.Child;
       // disconnect the function body from the tree
-      selectedCutPoint.Parent.RemoveSubTree(selectedCutPoint.ChildIndex);
+      selectedCutPoint.Parent.RemoveSubtree(selectedCutPoint.ChildIndex);
       // disconnect the argument branches from the function
       functionBody = DisconnectBranches(functionBody, argumentCutPoints);
       // insert a function invocation symbol instead
       var invokeNode = (InvokeFunctionTreeNode)(new InvokeFunction(newFunctionName)).CreateTreeNode();
-      selectedCutPoint.Parent.InsertSubTree(selectedCutPoint.ChildIndex, invokeNode);
+      selectedCutPoint.Parent.InsertSubtree(selectedCutPoint.ChildIndex, invokeNode);
       // add the branches selected as argument as subtrees of the function invocation node
       foreach (var argumentCutPoint in argumentCutPoints)
-        invokeNode.AddSubTree(argumentCutPoint.Child);
+        invokeNode.AddSubtree(argumentCutPoint.Child);
 
       // insert a new function defining branch
       var defunNode = (DefunTreeNode)(new Defun()).CreateTreeNode();
       defunNode.FunctionName = newFunctionName;
-      defunNode.AddSubTree(functionBody);
-      symbolicExpressionTree.Root.AddSubTree(defunNode);
+      defunNode.AddSubtree(functionBody);
+      symbolicExpressionTree.Root.AddSubtree(defunNode);
       // the grammar in the newly defined function is a clone of the grammar of the originating branch
       defunNode.SetGrammar((ISymbolicExpressionTreeGrammar)selectedBody.Grammar.Clone());
@@ -157,5 +157,5 @@
       if (selectedBody.Symbol is Defun) {
         var originalFunctionDefinition = selectedBody as DefunTreeNode;
-        foreach (var subtree in symbolicExpressionTree.Root.SubTrees) {
+        foreach (var subtree in symbolicExpressionTree.Root.Subtrees) {
           var originalBranchInvokeSymbol = (from symb in subtree.Grammar.Symbols.OfType<InvokeFunction>()
                                             where symb.FunctionName == originalFunctionDefinition.FunctionName
@@ -177,9 +177,9 @@
       }
       // remove the subtrees so that we can clone only the root node
-      List<ISymbolicExpressionTreeNode> subtrees = new List<ISymbolicExpressionTreeNode>(node.SubTrees);
-      while (node.SubTrees.Count() > 0) node.RemoveSubTree(0);
+      List<ISymbolicExpressionTreeNode> subtrees = new List<ISymbolicExpressionTreeNode>(node.Subtrees);
+      while (node.Subtrees.Count() > 0) node.RemoveSubtree(0);
       // recursively apply function for subtrees or append a argument terminal node
       foreach (var subtree in subtrees) {
-        node.AddSubTree(DisconnectBranches(subtree, argumentCutPoints));
+        node.AddSubtree(DisconnectBranches(subtree, argumentCutPoints));
       }
       return node;
@@ -198,5 +198,5 @@
       } else {
         // get the number of argument nodes (which must be cut-off) in the sub-trees
-        var numberOfArgumentsInSubtrees = (from subtree in selectedRoot.SubTrees
+        var numberOfArgumentsInSubtrees = (from subtree in selectedRoot.Subtrees
                                            let nArgumentsInTree = subtree.IterateNodesPrefix().OfType<ArgumentTreeNode>().Count()
                                            select nArgumentsInTree).ToList();
@@ -209,10 +209,10 @@
         }
         // cut-off in the sub-trees in random order
-        var randomIndexes = (from index in Enumerable.Range(0, selectedRoot.SubTrees.Count())
+        var randomIndexes = (from index in Enumerable.Range(0, selectedRoot.Subtrees.Count())
                              select new { Index = index, OrderValue = random.NextDouble() })
                              .OrderBy(x => x.OrderValue)
                              .Select(x => x.Index);
         foreach (var subtreeIndex in randomIndexes) {
-          var subtree = selectedRoot.GetSubTree(subtreeIndex);
+          var subtree = selectedRoot.GetSubtree(subtreeIndex);
           minNewArgumentsForSubtrees[subtreeIndex] = 0;
           // => cut-off at 0..n points somewhere in the current sub-tree
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/SubroutineDeleter.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/SubroutineDeleter.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/SubroutineDeleter.cs	(revision 5733)
@@ -62,9 +62,9 @@
       var selectedDefunBranch = functionDefiningBranches.SelectRandom(random);
       // remove the selected defun
-      int defunSubtreeIndex = symbolicExpressionTree.Root.IndexOfSubTree(selectedDefunBranch);
-      symbolicExpressionTree.Root.RemoveSubTree(defunSubtreeIndex);
+      int defunSubtreeIndex = symbolicExpressionTree.Root.IndexOfSubtree(selectedDefunBranch);
+      symbolicExpressionTree.Root.RemoveSubtree(defunSubtreeIndex);
 
       // remove references to deleted function
-      foreach (var subtree in symbolicExpressionTree.Root.SubTrees.OfType<SymbolicExpressionTreeTopLevelNode>()) {
+      foreach (var subtree in symbolicExpressionTree.Root.Subtrees.OfType<SymbolicExpressionTreeTopLevelNode>()) {
         var matchingInvokeSymbol = (from symb in subtree.Grammar.Symbols.OfType<InvokeFunction>()
                                     where symb.FunctionName == selectedDefunBranch.FunctionName
@@ -84,5 +84,5 @@
       // the invocations below it are removed already
       var invocationCutPoint = (from node in symbolicExpressionTree.IterateNodesPrefix()
-                                from subtree in node.SubTrees.OfType<InvokeFunctionTreeNode>()
+                                from subtree in node.Subtrees.OfType<InvokeFunctionTreeNode>()
                                 where subtree.Symbol.FunctionName == selectedDefunBranch.FunctionName
                                 select new CutPoint(node, subtree)).FirstOrDefault();
@@ -101,11 +101,11 @@
         if (replacementTree.HasLocalParameters)
           replacementTree.ResetLocalParameters(random);
-        invocationCutPoint.Parent.RemoveSubTree(invocationCutPoint.ChildIndex);
-        invocationCutPoint.Parent.InsertSubTree(invocationCutPoint.ChildIndex, replacementTree);
+        invocationCutPoint.Parent.RemoveSubtree(invocationCutPoint.ChildIndex);
+        invocationCutPoint.Parent.InsertSubtree(invocationCutPoint.ChildIndex, replacementTree);
 
         ProbabilisticTreeCreator.PTC2(random, replacementTree, maxLength, maxDepth);
 
         invocationCutPoint = (from node in symbolicExpressionTree.IterateNodesPrefix()
-                              from subtree in node.SubTrees.OfType<InvokeFunctionTreeNode>()
+                              from subtree in node.Subtrees.OfType<InvokeFunctionTreeNode>()
                               where subtree.Symbol.FunctionName == selectedDefunBranch.FunctionName
                               select new CutPoint(node, subtree)).FirstOrDefault();
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/SubroutineDuplicater.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/SubroutineDuplicater.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/SubroutineDuplicater.cs	(revision 5733)
@@ -71,8 +71,8 @@
       string newFunctionName = allowedFunctionNames.Except(UsedFunctionNames(symbolicExpressionTree)).First();
       duplicatedDefunBranch.FunctionName = newFunctionName;
-      symbolicExpressionTree.Root.AddSubTree(duplicatedDefunBranch);
+      symbolicExpressionTree.Root.AddSubtree(duplicatedDefunBranch);
       duplicatedDefunBranch.SetGrammar((ISymbolicExpressionTreeGrammar)selectedBranch.Grammar.Clone());
       // add an invoke symbol for each branch that is allowed to invoke the original function
-      foreach (var subtree in symbolicExpressionTree.Root.SubTrees.OfType<SymbolicExpressionTreeTopLevelNode>()) {
+      foreach (var subtree in symbolicExpressionTree.Root.Subtrees.OfType<SymbolicExpressionTreeTopLevelNode>()) {
         var matchingInvokeSymbol = (from symb in subtree.Grammar.Symbols.OfType<InvokeFunction>()
                                     where symb.FunctionName == selectedBranch.FunctionName
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Compiler/SymbolicExpressionTreeCompiler.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Compiler/SymbolicExpressionTreeCompiler.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Compiler/SymbolicExpressionTreeCompiler.cs	(revision 5733)
@@ -33,5 +33,5 @@
       entryPoint.Clear();
       // compile main body branches
-      foreach (var branch in tree.Root.GetSubTree(0).SubTrees) {
+      foreach (var branch in tree.Root.GetSubtree(0).Subtrees) {
         code.AddRange(Compile(branch, opCodeMapper));
       }
@@ -43,5 +43,5 @@
         if (code.Count > ushort.MaxValue) throw new ArgumentException("Code for the tree is too long (> ushort.MaxValue).");
         entryPoint[branch.FunctionName] = (ushort)code.Count;
-        code.AddRange(Compile(branch.GetSubTree(0), opCodeMapper));
+        code.AddRange(Compile(branch.GetSubtree(0), opCodeMapper));
       }
       // address of all functions is fixed now
@@ -62,7 +62,7 @@
       foreach (var node in branch.IterateNodesPrefix()) {
         Instruction instr = new Instruction();
-        int subTreesCount = node.SubTrees.Count();
-        if (subTreesCount > 255) throw new ArgumentException("Number of subtrees is too big (>255)");
-        instr.nArguments = (byte)subTreesCount;
+        int subtreesCount = node.SubtreesCount;
+        if (subtreesCount > 255) throw new ArgumentException("Number of subtrees is too big (>255)");
+        instr.nArguments = (byte)subtreesCount;
         instr.opCode = opCodeMapper(node);
         if (node.Symbol is Argument) {
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/ProbabilisticTreeCreator.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/ProbabilisticTreeCreator.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/ProbabilisticTreeCreator.cs	(revision 5733)
@@ -89,5 +89,5 @@
       startNode.SetGrammar(new SymbolicExpressionTreeGrammar(grammar));
       if (startNode.HasLocalParameters) startNode.ResetLocalParameters(random);
-      rootNode.AddSubTree(startNode);
+      rootNode.AddSubtree(startNode);
       PTC2(random, startNode, maxTreeLength, maxTreeDepth);
       tree.Root = rootNode;
@@ -120,5 +120,5 @@
         } else {
           // clean seedNode
-          while (seedNode.SubTrees.Count() > 0) seedNode.RemoveSubTree(0);
+          while (seedNode.Subtrees.Count() > 0) seedNode.RemoveSubtree(0);
         }
         // try a different length MAX_TRIES times
@@ -138,5 +138,5 @@
         // insert a dummy sub-tree and add the pending extension to the list
         var dummy = new SymbolicExpressionTreeNode();
-        root.AddSubTree(dummy);
+        root.AddSubtree(dummy);
         extensionPoints.Add(new TreeExtensionPoint { Parent = root, ChildIndex = i, ExtensionPointDepth = 0 });
       }
@@ -162,6 +162,6 @@
           ISymbolicExpressionTreeNode newTree = selectedSymbol.CreateTreeNode();
           if (newTree.HasLocalParameters) newTree.ResetLocalParameters(random);
-          parent.RemoveSubTree(argumentIndex);
-          parent.InsertSubTree(argumentIndex, newTree);
+          parent.RemoveSubtree(argumentIndex);
+          parent.InsertSubtree(argumentIndex, newTree);
 
           var topLevelNode = newTree as SymbolicExpressionTreeTopLevelNode;
@@ -177,5 +177,5 @@
             // insert a dummy sub-tree and add the pending extension to the list
             var dummy = new SymbolicExpressionTreeNode();
-            newTree.AddSubTree(dummy);
+            newTree.AddSubtree(dummy);
             extensionPoints.Add(new TreeExtensionPoint { Parent = newTree, ChildIndex = i, ExtensionPointDepth = extensionDepth + 1 });
           }
@@ -207,6 +207,6 @@
       var tree = selectedSymbol.CreateTreeNode();
       if (tree.HasLocalParameters) tree.ResetLocalParameters(random);
-      parent.RemoveSubTree(childIndex);
-      parent.InsertSubTree(childIndex, tree);
+      parent.RemoveSubtree(childIndex);
+      parent.InsertSubtree(childIndex, tree);
 
       var topLevelNode = tree as SymbolicExpressionTreeTopLevelNode;
@@ -217,5 +217,5 @@
         // insert a dummy sub-tree and add the pending extension to the list
         var dummy = new SymbolicExpressionTreeNode();
-        tree.AddSubTree(dummy);
+        tree.AddSubtree(dummy);
         // replace the just inserted dummy by recursive application
         ReplaceWithMinimalTree(random, root, tree, i);
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Crossovers/SubtreeCrossover.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Crossovers/SubtreeCrossover.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Crossovers/SubtreeCrossover.cs	(revision 5733)
@@ -93,5 +93,5 @@
 
       // calculate the max length and depth that the inserted branch can have 
-      int maxInsertedBranchLength = maxTreeLength - (parent0.Length - crossoverPoint0.GetSubTree(replacedSubtreeIndex).GetLength());
+      int maxInsertedBranchLength = maxTreeLength - (parent0.Length - crossoverPoint0.GetSubtree(replacedSubtreeIndex).GetLength());
       int maxInsertedBranchDepth = maxTreeDepth - GetBranchLevel(parent0.Root, crossoverPoint0);
 
@@ -111,6 +111,6 @@
         // manipulate the tree of parent0 in place
         // replace the branch in tree0 with the selected branch from tree1
-        crossoverPoint0.RemoveSubTree(replacedSubtreeIndex);
-        crossoverPoint0.InsertSubTree(replacedSubtreeIndex, selectedBranch);
+        crossoverPoint0.RemoveSubtree(replacedSubtreeIndex);
+        crossoverPoint0.InsertSubtree(replacedSubtreeIndex, selectedBranch);
         return parent0;
       }
@@ -139,9 +139,9 @@
       List<CutPoint> leafCrossoverPoints = new List<CutPoint>();
       parent0.Root.ForEachNodePostfix((n) => {
-        if (n.SubTrees.Any() && n != parent0.Root) {
-          foreach (var child in n.SubTrees) {
+        if (n.Subtrees.Any() && n != parent0.Root) {
+          foreach (var child in n.Subtrees) {
             if (child.GetLength() <= maxBranchLength &&
                 child.GetDepth() <= maxBranchDepth) {
-              if (child.SubTrees.Any())
+              if (child.Subtrees.Any())
                 internalCrossoverPoints.Add(new CutPoint(n, child));
               else
@@ -185,5 +185,5 @@
         // select internal node if possible
         allowedInternalBranches = (from branch in branches
-                                   where branch.SubTrees.Any()
+                                   where branch.Subtrees.Any()
                                    select branch).ToList();
         if (allowedInternalBranches.Count > 0) {
@@ -192,5 +192,5 @@
           // no internal nodes allowed => select leaf nodes
           allowedLeafBranches = (from branch in branches
-                                 where !branch.SubTrees.Any()
+                                 where !branch.Subtrees.Any()
                                  select branch).ToList();
           return allowedLeafBranches.SelectRandom(random);
@@ -199,5 +199,5 @@
         // select leaf node if possible
         allowedLeafBranches = (from branch in branches
-                               where !branch.SubTrees.Any()
+                               where !branch.Subtrees.Any()
                                select branch).ToList();
         if (allowedLeafBranches.Count > 0) {
@@ -205,5 +205,5 @@
         } else {
           allowedInternalBranches = (from branch in branches
-                                     where branch.SubTrees.Any()
+                                     where branch.Subtrees.Any()
                                      select branch).ToList();
           return allowedInternalBranches.SelectRandom(random);
@@ -214,5 +214,5 @@
     private static int GetBranchLevel(ISymbolicExpressionTreeNode root, ISymbolicExpressionTreeNode point) {
       if (root == point) return 0;
-      foreach (var subtree in root.SubTrees) {
+      foreach (var subtree in root.Subtrees) {
         int branchLevel = GetBranchLevel(subtree, point);
         if (branchLevel < int.MaxValue) return 1 + branchLevel;
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/CutPoint.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/CutPoint.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/CutPoint.cs	(revision 5733)
@@ -32,5 +32,5 @@
       this.Parent = parent;
       this.Child = child;
-      this.childIndex = parent.IndexOfSubTree(child);
+      this.childIndex = parent.IndexOfSubtree(child);
     }
   }
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Formatters/SymbolicExpressionTreeStringFormatter.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Formatters/SymbolicExpressionTreeStringFormatter.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Formatters/SymbolicExpressionTreeStringFormatter.cs	(revision 5733)
@@ -55,10 +55,10 @@
       strBuilder.Append("(");
       // internal nodes or leaf nodes?
-      if (node.SubTrees.Count() > 0) {
+      if (node.Subtrees.Count() > 0) {
         // symbol on same line as '('
         strBuilder.AppendLine(node.ToString());
         // each subtree expression on a new line
         // and closing ')' also on new line
-        foreach (var subtree in node.SubTrees) {
+        foreach (var subtree in node.Subtrees) {
           strBuilder.AppendLine(FormatRecursively(subtree, indentLength + 2));
         }
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionTreeNode.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionTreeNode.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionTreeNode.cs	(revision 5733)
@@ -38,11 +38,11 @@
     void ForEachNodePrefix(Action<ISymbolicExpressionTreeNode> a);
 
-    IEnumerable<ISymbolicExpressionTreeNode> SubTrees { get; }
+    IEnumerable<ISymbolicExpressionTreeNode> Subtrees { get; }
     int SubtreesCount { get; }
-    ISymbolicExpressionTreeNode GetSubTree(int index);
-    int IndexOfSubTree(ISymbolicExpressionTreeNode tree);
-    void AddSubTree(ISymbolicExpressionTreeNode tree);
-    void InsertSubTree(int index, ISymbolicExpressionTreeNode tree);
-    void RemoveSubTree(int index);
+    ISymbolicExpressionTreeNode GetSubtree(int index);
+    int IndexOfSubtree(ISymbolicExpressionTreeNode tree);
+    void AddSubtree(ISymbolicExpressionTreeNode tree);
+    void InsertSubtree(int index, ISymbolicExpressionTreeNode tree);
+    void RemoveSubtree(int index);
 
     void ResetLocalParameters(IRandom random);
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/ChangeNodeTypeManipulation.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/ChangeNodeTypeManipulation.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/ChangeNodeTypeManipulation.cs	(revision 5733)
@@ -45,8 +45,8 @@
       // select any node as parent (except the root node)
       var manipulationPoints = (from parent in symbolicExpressionTree.Root.IterateNodesPrefix().Skip(1)
-                                let subtreeCount = parent.SubTrees.Count()
+                                let subtreeCount = parent.Subtrees.Count()
                                 from subtreeIndex in Enumerable.Range(0, subtreeCount)
-                                let subtree = parent.GetSubTree(subtreeIndex)
-                                let existingSubtreeCount = subtree.SubTrees.Count()
+                                let subtree = parent.GetSubtree(subtreeIndex)
+                                let existingSubtreeCount = subtree.Subtrees.Count()
                                 // find possible symbols for the node (also considering the existing branches below it)
                                 let allowedSymbols = (from symbol in parent.Grammar.GetAllowedChildSymbols(parent.Symbol, subtreeIndex)
@@ -57,5 +57,5 @@
                                                       // keep only symbols that are still possible considering the existing sub-trees
                                                       where (from existingSubtreeIndex in Enumerable.Range(0, existingSubtreeCount)
-                                                             let existingSubtree = subtree.GetSubTree(existingSubtreeIndex)
+                                                             let existingSubtree = subtree.GetSubtree(existingSubtreeIndex)
                                                              select parent.Grammar.IsAllowedChildSymbol(symbol, existingSubtree.Symbol, existingSubtreeIndex))
                                                              .All(x => x == true)
@@ -75,8 +75,8 @@
       if (newNode.HasLocalParameters)
         newNode.ResetLocalParameters(random);
-      foreach (var subtree in selectedManipulationPoint.Child.SubTrees)
-        newNode.AddSubTree(subtree);
-      selectedManipulationPoint.Parent.RemoveSubTree(selectedManipulationPoint.Index);
-      selectedManipulationPoint.Parent.InsertSubTree(selectedManipulationPoint.Index, newNode);
+      foreach (var subtree in selectedManipulationPoint.Child.Subtrees)
+        newNode.AddSubtree(subtree);
+      selectedManipulationPoint.Parent.RemoveSubtree(selectedManipulationPoint.Index);
+      selectedManipulationPoint.Parent.InsertSubtree(selectedManipulationPoint.Index, newNode);
     }
   }
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/ReplaceBranchManipulation.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/ReplaceBranchManipulation.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/ReplaceBranchManipulation.cs	(revision 5733)
@@ -70,6 +70,6 @@
       // select any node as parent (except the root node)
       var manipulationPoints = (from parent in symbolicExpressionTree.Root.IterateNodesPrefix().Skip(1)
-                                from subtree in parent.SubTrees
-                                let subtreeIndex = parent.IndexOfSubTree(subtree)
+                                from subtree in parent.Subtrees
+                                let subtreeIndex = parent.IndexOfSubtree(subtree)
                                 let maxLength = maxTreeLength - symbolicExpressionTree.Length + subtree.GetLength()
                                 let maxDepth = maxTreeDepth - symbolicExpressionTree.Depth + subtree.GetDepth()
@@ -103,6 +103,6 @@
         seedNode.ResetLocalParameters(random);
 
-      selectedManipulationPoint.Parent.RemoveSubTree(selectedManipulationPoint.Index);
-      selectedManipulationPoint.Parent.InsertSubTree(selectedManipulationPoint.Index, seedNode);
+      selectedManipulationPoint.Parent.RemoveSubtree(selectedManipulationPoint.Index);
+      selectedManipulationPoint.Parent.InsertSubtree(selectedManipulationPoint.Index, seedNode);
       ProbabilisticTreeCreator.PTC2(random, seedNode, selectedManipulationPoint.MaxLength, selectedManipulationPoint.MaxDepth);
     }
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTreeNode.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTreeNode.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTreeNode.cs	(revision 5733)
@@ -30,5 +30,5 @@
   public class SymbolicExpressionTreeNode : DeepCloneable, ISymbolicExpressionTreeNode {
     [Storable]
-    private IList<ISymbolicExpressionTreeNode> subTrees;
+    private IList<ISymbolicExpressionTreeNode> subtrees;
     [Storable]
     private ISymbol symbol;
@@ -55,9 +55,9 @@
       : base() {
       symbol = original.symbol; // symbols are reused
-      subTrees = new List<ISymbolicExpressionTreeNode>(original.subTrees.Count);
-      foreach (var subtree in original.subTrees) {
-        var clonedSubTree = cloner.Clone(subtree);
-        subTrees.Add(clonedSubTree);
-        clonedSubTree.Parent = this;
+      subtrees = new List<ISymbolicExpressionTreeNode>(original.subtrees.Count);
+      foreach (var subtree in original.subtrees) {
+        var clonedSubtree = cloner.Clone(subtree);
+        subtrees.Add(clonedSubtree);
+        clonedSubtree.Parent = this;
       }
     }
@@ -74,5 +74,5 @@
     public SymbolicExpressionTreeNode(ISymbol symbol)
       : base() {
-      subTrees = new List<ISymbolicExpressionTreeNode>(3);
+      subtrees = new List<ISymbolicExpressionTreeNode>(3);
       this.symbol = symbol;
     }
@@ -81,6 +81,6 @@
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserialization() {
-      if (subTrees != null) {
-        foreach (var subtree in subTrees)
+      if (subtrees != null) {
+        foreach (var subtree in subtrees)
           subtree.Parent = this;
       }
@@ -91,6 +91,6 @@
     }
 
-    public virtual IEnumerable<ISymbolicExpressionTreeNode> SubTrees {
-      get { return subTrees; }
+    public virtual IEnumerable<ISymbolicExpressionTreeNode> Subtrees {
+      get { return subtrees; }
     }
 
@@ -103,7 +103,7 @@
       else {
         length = 1;
-        if (subTrees != null) {
-          for (int i = 0; i < subTrees.Count; i++) {
-            checked { length += (ushort)subTrees[i].GetLength(); }
+        if (subtrees != null) {
+          for (int i = 0; i < subtrees.Count; i++) {
+            checked { length += (ushort)subtrees[i].GetLength(); }
           }
         }
@@ -115,6 +115,6 @@
       if (depth > 0) return depth;
       else {
-        if (subTrees != null) {
-          for (int i = 0; i < subTrees.Count; i++) depth = Math.Max(depth, (ushort)subTrees[i].GetDepth());
+        if (subtrees != null) {
+          for (int i = 0; i < subtrees.Count; i++) depth = Math.Max(depth, (ushort)subtrees[i].GetDepth());
         }
         depth++;
@@ -128,28 +128,28 @@
     public int SubtreesCount {
       get {
-        if (subTrees == null) return 0;
-        return subTrees.Count;
+        if (subtrees == null) return 0;
+        return subtrees.Count;
       }
     }
 
-    public virtual ISymbolicExpressionTreeNode GetSubTree(int index) {
-      return subTrees[index];
+    public virtual ISymbolicExpressionTreeNode GetSubtree(int index) {
+      return subtrees[index];
     }
-    public virtual int IndexOfSubTree(ISymbolicExpressionTreeNode tree) {
-      return subTrees.IndexOf(tree);
+    public virtual int IndexOfSubtree(ISymbolicExpressionTreeNode tree) {
+      return subtrees.IndexOf(tree);
     }
-    public virtual void AddSubTree(ISymbolicExpressionTreeNode tree) {
-      subTrees.Add(tree);
+    public virtual void AddSubtree(ISymbolicExpressionTreeNode tree) {
+      subtrees.Add(tree);
       tree.Parent = this;
       ResetCachedValues();
     }
-    public virtual void InsertSubTree(int index, ISymbolicExpressionTreeNode tree) {
-      subTrees.Insert(index, tree);
+    public virtual void InsertSubtree(int index, ISymbolicExpressionTreeNode tree) {
+      subtrees.Insert(index, tree);
       tree.Parent = this;
       ResetCachedValues();
     }
-    public virtual void RemoveSubTree(int index) {
-      subTrees[index].Parent = null;
-      subTrees.RemoveAt(index);
+    public virtual void RemoveSubtree(int index) {
+      subtrees[index].Parent = null;
+      subtrees.RemoveAt(index);
       ResetCachedValues();
     }
@@ -163,6 +163,6 @@
     public void ForEachNodePrefix(Action<ISymbolicExpressionTreeNode> a) {
       a(this);
-      if (SubTrees != null) {
-        foreach (var subtree in SubTrees) {
+      if (Subtrees != null) {
+        foreach (var subtree in Subtrees) {
           subtree.ForEachNodePrefix(a);
         }
@@ -177,6 +177,6 @@
 
     public void ForEachNodePostfix(Action<ISymbolicExpressionTreeNode> a) {
-      if (SubTrees != null) {
-        foreach (var subtree in SubTrees) {
+      if (Subtrees != null) {
+        foreach (var subtree in Subtrees) {
           subtree.ForEachNodePostfix(a);
         }
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTreeTerminalNode.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTreeTerminalNode.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTreeTerminalNode.cs	(revision 5733)
@@ -29,5 +29,5 @@
   [StorableClass]
   public abstract class SymbolicExpressionTreeTerminalNode : SymbolicExpressionTreeNode {
-    public override IEnumerable<ISymbolicExpressionTreeNode> SubTrees {
+    public override IEnumerable<ISymbolicExpressionTreeNode> Subtrees {
       get {
         return Enumerable.Empty<ISymbolicExpressionTreeNode>();
@@ -51,17 +51,17 @@
     }
 
-    public override int IndexOfSubTree(ISymbolicExpressionTreeNode tree) {
+    public override int IndexOfSubtree(ISymbolicExpressionTreeNode tree) {
       return -1;
     }
-    public override ISymbolicExpressionTreeNode GetSubTree(int index) {
+    public override ISymbolicExpressionTreeNode GetSubtree(int index) {
       throw new NotSupportedException();
     }
-    public override void AddSubTree(ISymbolicExpressionTreeNode tree) {
+    public override void AddSubtree(ISymbolicExpressionTreeNode tree) {
       throw new NotSupportedException();
     }
-    public override void InsertSubTree(int index, ISymbolicExpressionTreeNode tree) {
+    public override void InsertSubtree(int index, ISymbolicExpressionTreeNode tree) {
       throw new NotSupportedException();
     }
-    public override void RemoveSubTree(int index) {
+    public override void RemoveSubtree(int index) {
       throw new NotSupportedException();
     }
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/AllArchitectureAlteringOperatorsTest.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/AllArchitectureAlteringOperatorsTest.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/AllArchitectureAlteringOperatorsTest.cs	(revision 5733)
@@ -110,5 +110,5 @@
         Util.GetSizeDistributionString(trees, 200, 5) + Environment.NewLine +
         Util.GetFunctionDistributionString(trees) + Environment.NewLine +
-        Util.GetNumberOfSubTreesDistributionString(trees) + Environment.NewLine +
+        Util.GetNumberOfSubtreesDistributionString(trees) + Environment.NewLine +
         Util.GetTerminalDistributionString(trees) + Environment.NewLine
         );
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/ArgumentCreaterTest.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/ArgumentCreaterTest.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/ArgumentCreaterTest.cs	(revision 5733)
@@ -72,5 +72,5 @@
         Util.GetSizeDistributionString(trees, 200, 20) + Environment.NewLine +
         Util.GetFunctionDistributionString(trees) + Environment.NewLine +
-        Util.GetNumberOfSubTreesDistributionString(trees) + Environment.NewLine +
+        Util.GetNumberOfSubtreesDistributionString(trees) + Environment.NewLine +
         Util.GetTerminalDistributionString(trees) + Environment.NewLine
         );
@@ -78,6 +78,6 @@
 
     private bool TreeHasAdfWithParameter(ISymbolicExpressionTree tree, int maxParameters) {
-      if (tree.Root.SubTrees.Count() != 2) return false;
-      var firstAdf = tree.Root.GetSubTree(1);
+      if (tree.Root.Subtrees.Count() != 2) return false;
+      var firstAdf = tree.Root.GetSubtree(1);
       return firstAdf.Grammar.GetAllowedChildSymbols(firstAdf.Symbol, 0).Where(x => x is Argument).Count() < maxParameters;
     }
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/ArgumentDeleterTest.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/ArgumentDeleterTest.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/ArgumentDeleterTest.cs	(revision 5733)
@@ -67,11 +67,11 @@
         Util.GetSizeDistributionString(trees, 105, 5) + Environment.NewLine +
         Util.GetFunctionDistributionString(trees) + Environment.NewLine +
-        Util.GetNumberOfSubTreesDistributionString(trees) + Environment.NewLine +
+        Util.GetNumberOfSubtreesDistributionString(trees) + Environment.NewLine +
         Util.GetTerminalDistributionString(trees) + Environment.NewLine
         );
     }
     private bool TreeHasAdfWithArguments(ISymbolicExpressionTree tree) {
-      if (tree.Root.SubTrees.Count() != 2) return false;
-      var firstAdf = tree.Root.GetSubTree(1);
+      if (tree.Root.Subtrees.Count() != 2) return false;
+      var firstAdf = tree.Root.GetSubtree(1);
       return firstAdf.Grammar.GetAllowedChildSymbols(firstAdf.Symbol, 0).Where(x => x is Argument).Count() >= 2;
     }
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/ArgumentDuplicaterTest.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/ArgumentDuplicaterTest.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/ArgumentDuplicaterTest.cs	(revision 5733)
@@ -67,5 +67,5 @@
         Util.GetSizeDistributionString(trees, 200, 5) + Environment.NewLine +
         Util.GetFunctionDistributionString(trees) + Environment.NewLine +
-        Util.GetNumberOfSubTreesDistributionString(trees) + Environment.NewLine +
+        Util.GetNumberOfSubtreesDistributionString(trees) + Environment.NewLine +
         Util.GetTerminalDistributionString(trees) + Environment.NewLine
         );
@@ -73,6 +73,6 @@
 
     private bool HasAdfWithArguments(ISymbolicExpressionTree tree) {
-      if (tree.Root.SubTrees.Count() != 2) return false;
-      var firstAdf = tree.Root.GetSubTree(1);
+      if (tree.Root.Subtrees.Count() != 2) return false;
+      var firstAdf = tree.Root.GetSubtree(1);
       return firstAdf.Grammar.GetAllowedChildSymbols(firstAdf.Symbol, 0).Where(x => x is Argument).Count() == 1;
     }
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/ChangeNodeTypeManipulationTest.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/ChangeNodeTypeManipulationTest.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/ChangeNodeTypeManipulationTest.cs	(revision 5733)
@@ -67,5 +67,5 @@
         Util.GetSizeDistributionString(trees, 105, 5) + Environment.NewLine +
         Util.GetFunctionDistributionString(trees) + Environment.NewLine +
-        Util.GetNumberOfSubTreesDistributionString(trees) + Environment.NewLine +
+        Util.GetNumberOfSubtreesDistributionString(trees) + Environment.NewLine +
         Util.GetTerminalDistributionString(trees) + Environment.NewLine
         );
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/ProbabilisticTreeCreaterTest.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/ProbabilisticTreeCreaterTest.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/ProbabilisticTreeCreaterTest.cs	(revision 5733)
@@ -69,5 +69,5 @@
         Util.GetSizeDistributionString(randomTrees, 105, 5) + Environment.NewLine +
         Util.GetFunctionDistributionString(randomTrees) + Environment.NewLine +
-        Util.GetNumberOfSubTreesDistributionString(randomTrees) + Environment.NewLine +
+        Util.GetNumberOfSubtreesDistributionString(randomTrees) + Environment.NewLine +
         Util.GetTerminalDistributionString(randomTrees) + Environment.NewLine
         );
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/ReplaceBranchManipulationTest.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/ReplaceBranchManipulationTest.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/ReplaceBranchManipulationTest.cs	(revision 5733)
@@ -66,5 +66,5 @@
         Util.GetSizeDistributionString(trees, 105, 5) + Environment.NewLine +
         Util.GetFunctionDistributionString(trees) + Environment.NewLine +
-        Util.GetNumberOfSubTreesDistributionString(trees) + Environment.NewLine +
+        Util.GetNumberOfSubtreesDistributionString(trees) + Environment.NewLine +
         Util.GetTerminalDistributionString(trees) + Environment.NewLine
         );
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/SubroutineCreaterTest.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/SubroutineCreaterTest.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/SubroutineCreaterTest.cs	(revision 5733)
@@ -63,5 +63,5 @@
         Util.GetSizeDistributionString(trees, 105, 5) + Environment.NewLine +
         Util.GetFunctionDistributionString(trees) + Environment.NewLine +
-        Util.GetNumberOfSubTreesDistributionString(trees) + Environment.NewLine +
+        Util.GetNumberOfSubtreesDistributionString(trees) + Environment.NewLine +
         Util.GetTerminalDistributionString(trees) + Environment.NewLine
         );
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/SubroutineDeleterTest.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/SubroutineDeleterTest.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/SubroutineDeleterTest.cs	(revision 5733)
@@ -68,5 +68,5 @@
         Util.GetSizeDistributionString(trees, 105, 5) + Environment.NewLine +
         Util.GetFunctionDistributionString(trees) + Environment.NewLine +
-        Util.GetNumberOfSubTreesDistributionString(trees) + Environment.NewLine +
+        Util.GetNumberOfSubtreesDistributionString(trees) + Environment.NewLine +
         Util.GetTerminalDistributionString(trees) + Environment.NewLine
         );
@@ -74,5 +74,5 @@
 
     private bool HasAtLeastOneAdf(ISymbolicExpressionTree tree) {
-      return tree.Root.SubTrees.Count() > 1;
+      return tree.Root.Subtrees.Count() > 1;
     }
   }
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/SubroutineDuplicaterTest.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/SubroutineDuplicaterTest.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/SubroutineDuplicaterTest.cs	(revision 5733)
@@ -68,5 +68,5 @@
         Util.GetSizeDistributionString(trees, 105, 5) + Environment.NewLine +
         Util.GetFunctionDistributionString(trees) + Environment.NewLine +
-        Util.GetNumberOfSubTreesDistributionString(trees) + Environment.NewLine +
+        Util.GetNumberOfSubtreesDistributionString(trees) + Environment.NewLine +
         Util.GetTerminalDistributionString(trees) + Environment.NewLine
         );
@@ -74,5 +74,5 @@
 
     private bool HasOneAdf(ISymbolicExpressionTree tree) {
-      return tree.Root.SubTrees.Count() == 2;
+      return tree.Root.Subtrees.Count() == 2;
     }
   }
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/SubtreeCrossoverTest.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/SubtreeCrossoverTest.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/SubtreeCrossoverTest.cs	(revision 5733)
@@ -81,5 +81,5 @@
         Util.GetSizeDistributionString(trees, 105, 5) + Environment.NewLine +
         Util.GetFunctionDistributionString(trees) + Environment.NewLine +
-        Util.GetNumberOfSubTreesDistributionString(trees) + Environment.NewLine +
+        Util.GetNumberOfSubtreesDistributionString(trees) + Environment.NewLine +
         Util.GetTerminalDistributionString(trees) + Environment.NewLine
         );
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/Util.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/Util.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/Util.cs	(revision 5733)
@@ -53,5 +53,5 @@
       for (int i = 0; i < trees.Count; i++) {
         foreach (var node in trees[i].IterateNodesPrefix()) {
-          if (node.SubTrees.Count() > 0) {
+          if (node.Subtrees.Count() > 0) {
             if (!occurances.ContainsKey(node.Symbol.Name))
               occurances[node.Symbol.Name] = 0;
@@ -70,12 +70,12 @@
     }
 
-    public static string GetNumberOfSubTreesDistributionString(IList<ISymbolicExpressionTree> trees) {
+    public static string GetNumberOfSubtreesDistributionString(IList<ISymbolicExpressionTree> trees) {
       Dictionary<int, int> occurances = new Dictionary<int, int>();
       double n = 0.0;
       for (int i = 0; i < trees.Count; i++) {
         foreach (var node in trees[i].IterateNodesPrefix()) {
-          if (!occurances.ContainsKey(node.SubTrees.Count()))
-            occurances[node.SubTrees.Count()] = 0;
-          occurances[node.SubTrees.Count()]++;
+          if (!occurances.ContainsKey(node.Subtrees.Count()))
+            occurances[node.Subtrees.Count()] = 0;
+          occurances[node.Subtrees.Count()]++;
           n++;
         }
@@ -96,5 +96,5 @@
       for (int i = 0; i < trees.Count; i++) {
         foreach (var node in trees[i].IterateNodesPrefix()) {
-          if (node.SubTrees.Count() == 0) {
+          if (node.Subtrees.Count() == 0) {
             if (!occurances.ContainsKey(node.Symbol.Name))
               occurances[node.Symbol.Name] = 0;
@@ -118,5 +118,5 @@
       Assert.AreEqual(actualSize, reportedSize);
 
-      foreach (var defunTreeNode in tree.Root.SubTrees.OfType<DefunTreeNode>()) {
+      foreach (var defunTreeNode in tree.Root.Subtrees.OfType<DefunTreeNode>()) {
         int arity = defunTreeNode.NumberOfArguments;
 
@@ -133,5 +133,5 @@
 
         var invoke = new InvokeFunction(defunTreeNode.FunctionName);
-        foreach (var otherRootNode in tree.Root.SubTrees) {
+        foreach (var otherRootNode in tree.Root.Subtrees) {
           if (otherRootNode.Grammar.ContainsSymbol(invoke)) {
             Assert.IsTrue(otherRootNode.Grammar.GetMinimumSubtreeCount(invoke) == arity);
@@ -141,5 +141,5 @@
 
       }
-      foreach (var subtree in tree.Root.SubTrees) {
+      foreach (var subtree in tree.Root.Subtrees) {
         Assert.AreNotSame(subtree.Grammar, tree.Root.Grammar);
         IsValid(subtree.Grammar);
@@ -165,10 +165,10 @@
                             where symb.Name == treeNode.Symbol.Name
                             select symb).SingleOrDefault();
-      Assert.IsTrue(treeNode.SubTrees.Count() >= treeNode.Grammar.GetMinimumSubtreeCount(matchingSymbol));
-      Assert.IsTrue(treeNode.SubTrees.Count() <= treeNode.Grammar.GetMaximumSubtreeCount(matchingSymbol));
+      Assert.IsTrue(treeNode.Subtrees.Count() >= treeNode.Grammar.GetMinimumSubtreeCount(matchingSymbol));
+      Assert.IsTrue(treeNode.Subtrees.Count() <= treeNode.Grammar.GetMaximumSubtreeCount(matchingSymbol));
       Assert.AreNotEqual(0.0, matchingSymbol.InitialFrequency); // check that no deactivated symbols occur in the tree
-      for (int i = 0; i < treeNode.SubTrees.Count(); i++) {
-        Assert.IsTrue(treeNode.Grammar.GetAllowedChildSymbols(treeNode.Symbol, i).Select(x => x.Name).Contains(treeNode.GetSubTree(i).Symbol.Name));
-        IsValid(treeNode.GetSubTree(i));
+      for (int i = 0; i < treeNode.Subtrees.Count(); i++) {
+        Assert.IsTrue(treeNode.Grammar.GetAllowedChildSymbols(treeNode.Symbol, i).Select(x => x.Name).Contains(treeNode.GetSubtree(i).Symbol.Name));
+        IsValid(treeNode.GetSubtree(i));
       }
     }
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.ArtificialAnt/3.4/AntInterpreter.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.ArtificialAnt/3.4/AntInterpreter.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.ArtificialAnt/3.4/AntInterpreter.cs	(revision 5733)
@@ -51,5 +51,5 @@
 
     private SymbolicExpressionTreeNode FindMatchingFunction(string name) {
-      foreach (var defunBranch in expression.Root.SubTrees.OfType<DefunTreeNode>()) {
+      foreach (var defunBranch in expression.Root.Subtrees.OfType<DefunTreeNode>()) {
         if (defunBranch.FunctionName == name) return defunBranch;
       }
@@ -93,5 +93,5 @@
       // expression evaluated completly => start at root again
       if (nodeStack.Count == 0) {
-        nodeStack.Push(Expression.Root.GetSubTree(0).GetSubTree(0));
+        nodeStack.Push(Expression.Root.GetSubtree(0).GetSubtree(0));
       }
 
@@ -114,16 +114,16 @@
         NextField(out nextAntLocationRow, out nextAntLocationColumn);
         if (World[nextAntLocationRow, nextAntLocationColumn]) {
-          nodeStack.Push(currentNode.GetSubTree(0));
+          nodeStack.Push(currentNode.GetSubtree(0));
         } else {
-          nodeStack.Push(currentNode.GetSubTree(1));
+          nodeStack.Push(currentNode.GetSubtree(1));
         }
       } else if (currentNode.Symbol is Prog2) {
-        nodeStack.Push(currentNode.GetSubTree(1));
-        nodeStack.Push(currentNode.GetSubTree(0));
+        nodeStack.Push(currentNode.GetSubtree(1));
+        nodeStack.Push(currentNode.GetSubtree(0));
         return;
       } else if (currentNode.Symbol is Prog3) {
-        nodeStack.Push(currentNode.GetSubTree(2));
-        nodeStack.Push(currentNode.GetSubTree(1));
-        nodeStack.Push(currentNode.GetSubTree(0));
+        nodeStack.Push(currentNode.GetSubtree(2));
+        nodeStack.Push(currentNode.GetSubtree(1));
+        nodeStack.Push(currentNode.GetSubtree(0));
         return;
       } else if (currentNode.Symbol is InvokeFunction) {
@@ -131,13 +131,13 @@
         var functionDefinition = (SymbolicExpressionTreeNode)FindMatchingFunction(invokeNode.Symbol.FunctionName).Clone();
         var argumentCutPoints = (from node in functionDefinition.IterateNodesPrefix()
-                                 where node.SubTrees.Count() > 0
-                                 from subtree in node.SubTrees
+                                 where node.Subtrees.Count() > 0
+                                 from subtree in node.Subtrees
                                  where subtree is ArgumentTreeNode
-                                 select new { Parent = node, Argument = subtree.Symbol as Argument, ChildIndex = node.IndexOfSubTree(subtree) }).ToList();
+                                 select new { Parent = node, Argument = subtree.Symbol as Argument, ChildIndex = node.IndexOfSubtree(subtree) }).ToList();
         foreach (var cutPoint in argumentCutPoints) {
-          cutPoint.Parent.RemoveSubTree(cutPoint.ChildIndex);
-          cutPoint.Parent.InsertSubTree(cutPoint.ChildIndex, (SymbolicExpressionTreeNode)invokeNode.GetSubTree(cutPoint.Argument.ArgumentIndex).Clone());
+          cutPoint.Parent.RemoveSubtree(cutPoint.ChildIndex);
+          cutPoint.Parent.InsertSubtree(cutPoint.ChildIndex, (SymbolicExpressionTreeNode)invokeNode.GetSubtree(cutPoint.Argument.ArgumentIndex).Clone());
         }
-        nodeStack.Push(functionDefinition.GetSubTree(0));
+        nodeStack.Push(functionDefinition.GetSubtree(0));
       } else {
         throw new InvalidOperationException(currentNode.Symbol.ToString());
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective/SymbolicClassificationMultiObjectiveProblem.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective/SymbolicClassificationMultiObjectiveProblem.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective/SymbolicClassificationMultiObjectiveProblem.cs	(revision 5733)
@@ -30,5 +30,5 @@
   [StorableClass]
   [Creatable("Problems")]
-  public class SymbolicClassificationMultiObjectiveProblem : SymbolicDataAnalysisMultiObjectiveProblem<IClassificationProblemData, ISymbolicClassificationMultiObjectiveEvaluator, ISymbolicDataAnalysisSolutionCreator> {
+  public class SymbolicClassificationMultiObjectiveProblem : SymbolicDataAnalysisMultiObjectiveProblem<IClassificationProblemData, ISymbolicClassificationMultiObjectiveEvaluator, ISymbolicDataAnalysisSolutionCreator>, IClassificationProblem {
     private const double PunishmentFactor = 10;
     private const int InitialMaximumTreeDepth = 8;
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveProblem.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveProblem.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveProblem.cs	(revision 5733)
@@ -30,5 +30,5 @@
   [StorableClass]
   [Creatable("Problems")]
-  public class SymbolicClassificationSingleObjectiveProblem : SymbolicDataAnalysisSingleObjectiveProblem<IClassificationProblemData, ISymbolicClassificationSingleObjectiveEvaluator, ISymbolicDataAnalysisSolutionCreator> {
+  public class SymbolicClassificationSingleObjectiveProblem : SymbolicDataAnalysisSingleObjectiveProblem<IClassificationProblemData, ISymbolicClassificationSingleObjectiveEvaluator, ISymbolicDataAnalysisSolutionCreator>, IClassificationProblem {
     private const double PunishmentFactor = 10;
     private const int InitialMaximumTreeDepth = 8;
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4.csproj
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4.csproj	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4.csproj	(revision 5733)
@@ -111,6 +111,4 @@
     <Compile Include="SymbolicRegressionModel.cs" />
     <Compile Include="Interfaces\ISymbolicRegressionModel.cs" />
-    <Compile Include="Interfaces\ISymbolicRegressionProblem.cs" />
-    <Compile Include="Interfaces\ISymbolicRegressionSingleObjectiveProblem.cs" />
     <Compile Include="Interfaces\ISymbolicRegressionSolution.cs" />
     <Compile Include="Interfaces\ISymbolicRegressionEvaluator.cs" />
Index: anches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/Interfaces/ISymbolicRegressionProblem.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/Interfaces/ISymbolicRegressionProblem.cs	(revision 5732)
+++ 	(revision )
@@ -1,26 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-
-namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
-  public interface ISymbolicRegressionProblem : ISymbolicDataAnalysisProblem, IRegressionProblem {
-  }
-}
Index: anches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/Interfaces/ISymbolicRegressionSingleObjectiveProblem.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/Interfaces/ISymbolicRegressionSingleObjectiveProblem.cs	(revision 5732)
+++ 	(revision )
@@ -1,28 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using HeuristicLab.Optimization;
-
-namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
-  public interface ISymbolicRegressionSingleObjectiveProblem : ISymbolicRegressionProblem, ISingleObjectiveHeuristicOptimizationProblem {
-    new ISymbolicRegressionSingleObjectiveEvaluator Evaluator { get; }
-  }
-}
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveProblem.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveProblem.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveProblem.cs	(revision 5733)
@@ -31,5 +31,5 @@
   [StorableClass]
   [Creatable("Problems")]
-  public class SymbolicRegressionMultiObjectiveProblem : SymbolicDataAnalysisMultiObjectiveProblem<IRegressionProblemData, ISymbolicRegressionMultiObjectiveEvaluator, ISymbolicDataAnalysisSolutionCreator> {
+  public class SymbolicRegressionMultiObjectiveProblem : SymbolicDataAnalysisMultiObjectiveProblem<IRegressionProblemData, ISymbolicRegressionMultiObjectiveEvaluator, ISymbolicDataAnalysisSolutionCreator>, IRegressionProblem {
     private const double PunishmentFactor = 10;
     private const int InitialMaximumTreeDepth = 8;
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveProblem.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveProblem.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveProblem.cs	(revision 5733)
@@ -31,5 +31,5 @@
   [StorableClass]
   [Creatable("Problems")]
-  public class SymbolicRegressionSingleObjectiveProblem : SymbolicDataAnalysisSingleObjectiveProblem<IRegressionProblemData, ISymbolicRegressionSingleObjectiveEvaluator, ISymbolicDataAnalysisSolutionCreator> {
+  public class SymbolicRegressionSingleObjectiveProblem : SymbolicDataAnalysisSingleObjectiveProblem<IRegressionProblemData, ISymbolicRegressionSingleObjectiveEvaluator, ISymbolicDataAnalysisSolutionCreator>,IRegressionProblem {
     private const double PunishmentFactor = 10;
     private const int InitialMaximumTreeDepth = 8;
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionSolution.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionSolution.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionSolution.cs	(revision 5733)
@@ -73,12 +73,12 @@
       ConstantTreeNode betaTreeNode = null;
       // check if model has been scaled previously by analyzing the structure of the tree
-      var startNode = Model.SymbolicExpressionTree.Root.GetSubTree(0);
-      if (startNode.GetSubTree(0).Symbol is Addition) {
-        var addNode = startNode.GetSubTree(0);
-        if (addNode.SubtreesCount == 2 && addNode.GetSubTree(0).Symbol is Multiplication && addNode.GetSubTree(1).Symbol is Constant) {
-          alphaTreeNode = addNode.GetSubTree(1) as ConstantTreeNode;
-          var mulNode = addNode.GetSubTree(0);
-          if (mulNode.SubtreesCount == 2 && mulNode.GetSubTree(1).Symbol is Constant) {
-            betaTreeNode = mulNode.GetSubTree(1) as ConstantTreeNode;
+      var startNode = Model.SymbolicExpressionTree.Root.GetSubtree(0);
+      if (startNode.GetSubtree(0).Symbol is Addition) {
+        var addNode = startNode.GetSubtree(0);
+        if (addNode.SubtreesCount == 2 && addNode.GetSubtree(0).Symbol is Multiplication && addNode.GetSubtree(1).Symbol is Constant) {
+          alphaTreeNode = addNode.GetSubtree(1) as ConstantTreeNode;
+          var mulNode = addNode.GetSubtree(0);
+          if (mulNode.SubtreesCount == 2 && mulNode.GetSubtree(1).Symbol is Constant) {
+            betaTreeNode = mulNode.GetSubtree(1) as ConstantTreeNode;
           }
         }
@@ -90,8 +90,8 @@
         alphaTreeNode.Value += alpha;
       } else {
-        var mainBranch = startNode.GetSubTree(0);
-        startNode.RemoveSubTree(0);
+        var mainBranch = startNode.GetSubtree(0);
+        startNode.RemoveSubtree(0);
         var scaledMainBranch = MakeSum(MakeProduct(beta, mainBranch), alpha);
-        startNode.AddSubTree(scaledMainBranch);
+        startNode.AddSubtree(scaledMainBranch);
       }
 
@@ -105,6 +105,6 @@
         var node = (new Addition()).CreateTreeNode();
         var alphaConst = MakeConstant(alpha);
-        node.AddSubTree(treeNode);
-        node.AddSubTree(alphaConst);
+        node.AddSubtree(treeNode);
+        node.AddSubtree(alphaConst);
         return node;
       }
@@ -117,6 +117,6 @@
         var node = (new Multiplication()).CreateTreeNode();
         var betaConst = MakeConstant(beta);
-        node.AddSubTree(treeNode);
-        node.AddSubTree(betaConst);
+        node.AddSubtree(treeNode);
+        node.AddSubtree(betaConst);
         return node;
       }
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisVariableFrequencyAnalyzer.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisVariableFrequencyAnalyzer.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisVariableFrequencyAnalyzer.cs	(revision 5733)
@@ -153,19 +153,19 @@
         var varCondNode = node as VariableConditionTreeNode;
         IncReferenceCount(references, varCondNode.VariableName, currentLag);
-        GetVariableReferences(references, node.GetSubTree(0), currentLag);
-        GetVariableReferences(references, node.GetSubTree(1), currentLag);
+        GetVariableReferences(references, node.GetSubtree(0), currentLag);
+        GetVariableReferences(references, node.GetSubtree(1), currentLag);
       } else if (node.Symbol is Integral) {
         var laggedNode = node as LaggedTreeNode;
         for (int l = laggedNode.Lag; l <= 0; l++) {
-          GetVariableReferences(references, node.GetSubTree(0), currentLag + l);
+          GetVariableReferences(references, node.GetSubtree(0), currentLag + l);
         }
       } else if (node.Symbol is Derivative) {
         var laggedNode = node as LaggedTreeNode;
         for (int l = laggedNode.Lag; l <= 0; l++) {
-          GetVariableReferences(references, node.GetSubTree(0), currentLag + l);
+          GetVariableReferences(references, node.GetSubtree(0), currentLag + l);
         }
       } else if (node.Symbol is TimeLag) {
         var laggedNode = node as LaggedTreeNode;
-        GetVariableReferences(references, node.GetSubTree(0), currentLag + laggedNode.Lag);
+        GetVariableReferences(references, node.GetSubtree(0), currentLag + laggedNode.Lag);
       }
     }
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj	(revision 5733)
@@ -185,5 +185,4 @@
     <Compile Include="Interfaces\ISymbolicDataAnalysisSolution.cs" />
     <Compile Include="Interfaces\ISymbolicDataAnalysisSolutionCreator.cs" />
-    <Compile Include="Interfaces\ISymbolicDataAnalysisProblem.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
Index: anches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/ISymbolicDataAnalysisProblem.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/ISymbolicDataAnalysisProblem.cs	(revision 5732)
+++ 	(revision )
@@ -1,27 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using HeuristicLab.Optimization;
-namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
-  public interface ISymbolicDataAnalysisProblem : IDataAnalysisProblem, IHeuristicOptimizationProblem {
-    ISymbolicDataAnalysisGrammar SymbolicExpressionTreeGrammar { get; }
-  }
-}
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeSimplifier.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeSimplifier.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeSimplifier.cs	(revision 5733)
@@ -55,7 +55,7 @@
       var clone = (ISymbolicExpressionTreeNode)originalTree.Root.Clone();
       // macro expand (initially no argument trees)
-      var macroExpandedTree = MacroExpand(clone, clone.GetSubTree(0), new List<ISymbolicExpressionTreeNode>());
+      var macroExpandedTree = MacroExpand(clone, clone.GetSubtree(0), new List<ISymbolicExpressionTreeNode>());
       ISymbolicExpressionTreeNode rootNode = (new ProgramRootSymbol()).CreateTreeNode();
-      rootNode.AddSubTree(GetSimplifiedTree(macroExpandedTree));
+      rootNode.AddSubtree(GetSimplifiedTree(macroExpandedTree));
       return new SymbolicExpressionTree(rootNode);
     }
@@ -63,6 +63,6 @@
     // the argumentTrees list contains already expanded trees used as arguments for invocations
     private ISymbolicExpressionTreeNode MacroExpand(ISymbolicExpressionTreeNode root, ISymbolicExpressionTreeNode node, IList<ISymbolicExpressionTreeNode> argumentTrees) {
-      List<ISymbolicExpressionTreeNode> subtrees = new List<ISymbolicExpressionTreeNode>(node.SubTrees);
-      while (node.SubTrees.Count() > 0) node.RemoveSubTree(0);
+      List<ISymbolicExpressionTreeNode> subtrees = new List<ISymbolicExpressionTreeNode>(node.Subtrees);
+      while (node.SubtreesCount > 0) node.RemoveSubtree(0);
       if (node.Symbol is InvokeFunction) {
         var invokeSym = node.Symbol as InvokeFunction;
@@ -80,5 +80,5 @@
         // recursive application
         foreach (var subtree in subtrees) {
-          node.AddSubTree(MacroExpand(root, subtree, argumentTrees));
+          node.AddSubtree(MacroExpand(root, subtree, argumentTrees));
         }
         return node;
@@ -87,6 +87,6 @@
 
     private ISymbolicExpressionTreeNode FindFunctionDefinition(ISymbolicExpressionTreeNode root, string functionName) {
-      foreach (var subtree in root.SubTrees.OfType<DefunTreeNode>()) {
-        if (subtree.FunctionName == functionName) return subtree.GetSubTree(0);
+      foreach (var subtree in root.Subtrees.OfType<DefunTreeNode>()) {
+        if (subtree.FunctionName == functionName) return subtree.GetSubtree(0);
       }
 
@@ -232,16 +232,16 @@
     private ISymbolicExpressionTreeNode SimplifyAny(ISymbolicExpressionTreeNode original) {
       // can't simplify this function but simplify all subtrees 
-      List<ISymbolicExpressionTreeNode> subTrees = new List<ISymbolicExpressionTreeNode>(original.SubTrees);
-      while (original.SubTrees.Count() > 0) original.RemoveSubTree(0);
+      List<ISymbolicExpressionTreeNode> subtrees = new List<ISymbolicExpressionTreeNode>(original.Subtrees);
+      while (original.Subtrees.Count() > 0) original.RemoveSubtree(0);
       var clone = (SymbolicExpressionTreeNode)original.Clone();
-      List<ISymbolicExpressionTreeNode> simplifiedSubTrees = new List<ISymbolicExpressionTreeNode>();
-      foreach (var subTree in subTrees) {
-        simplifiedSubTrees.Add(GetSimplifiedTree(subTree));
-        original.AddSubTree(subTree);
-      }
-      foreach (var simplifiedSubtree in simplifiedSubTrees) {
-        clone.AddSubTree(simplifiedSubtree);
-      }
-      if (simplifiedSubTrees.TrueForAll(t => IsConstant(t))) {
+      List<ISymbolicExpressionTreeNode> simplifiedSubtrees = new List<ISymbolicExpressionTreeNode>();
+      foreach (var subtree in subtrees) {
+        simplifiedSubtrees.Add(GetSimplifiedTree(subtree));
+        original.AddSubtree(subtree);
+      }
+      foreach (var simplifiedSubtree in simplifiedSubtrees) {
+        clone.AddSubtree(simplifiedSubtree);
+      }
+      if (simplifiedSubtrees.TrueForAll(t => IsConstant(t))) {
         SimplifyConstantExpression(clone);
       }
@@ -255,25 +255,25 @@
 
     private ISymbolicExpressionTreeNode SimplifyAverage(ISymbolicExpressionTreeNode original) {
-      if (original.SubTrees.Count() == 1) {
-        return GetSimplifiedTree(original.GetSubTree(0));
+      if (original.Subtrees.Count() == 1) {
+        return GetSimplifiedTree(original.GetSubtree(0));
       } else {
         // simplify expressions x0..xn
         // make sum(x0..xn) / n
-        Trace.Assert(original.SubTrees.Count() > 1);
-        var sum = original.SubTrees
+        Trace.Assert(original.Subtrees.Count() > 1);
+        var sum = original.Subtrees
           .Select(x => GetSimplifiedTree(x))
           .Aggregate((a, b) => MakeSum(a, b));
-        return MakeFraction(sum, MakeConstant(original.SubTrees.Count()));
+        return MakeFraction(sum, MakeConstant(original.Subtrees.Count()));
       }
     }
 
     private ISymbolicExpressionTreeNode SimplifyDivision(ISymbolicExpressionTreeNode original) {
-      if (original.SubTrees.Count() == 1) {
-        return Invert(GetSimplifiedTree(original.GetSubTree(0)));
+      if (original.Subtrees.Count() == 1) {
+        return Invert(GetSimplifiedTree(original.GetSubtree(0)));
       } else {
         // simplify expressions x0..xn
         // make multiplication (x0 * 1/(x1 * x1 * .. * xn))
-        Trace.Assert(original.SubTrees.Count() > 1);
-        var simplifiedTrees = original.SubTrees.Select(x => GetSimplifiedTree(x));
+        Trace.Assert(original.Subtrees.Count() > 1);
+        var simplifiedTrees = original.Subtrees.Select(x => GetSimplifiedTree(x));
         return
           MakeProduct(simplifiedTrees.First(), Invert(simplifiedTrees.Skip(1).Aggregate((a, b) => MakeProduct(a, b))));
@@ -282,9 +282,9 @@
 
     private ISymbolicExpressionTreeNode SimplifyMultiplication(ISymbolicExpressionTreeNode original) {
-      if (original.SubTrees.Count() == 1) {
-        return GetSimplifiedTree(original.GetSubTree(0));
-      } else {
-        Trace.Assert(original.SubTrees.Count() > 1);
-        return original.SubTrees
+      if (original.Subtrees.Count() == 1) {
+        return GetSimplifiedTree(original.GetSubtree(0));
+      } else {
+        Trace.Assert(original.Subtrees.Count() > 1);
+        return original.Subtrees
           .Select(x => GetSimplifiedTree(x))
           .Aggregate((a, b) => MakeProduct(a, b));
@@ -293,11 +293,11 @@
 
     private ISymbolicExpressionTreeNode SimplifySubtraction(ISymbolicExpressionTreeNode original) {
-      if (original.SubTrees.Count() == 1) {
-        return Negate(GetSimplifiedTree(original.GetSubTree(0)));
+      if (original.Subtrees.Count() == 1) {
+        return Negate(GetSimplifiedTree(original.GetSubtree(0)));
       } else {
         // simplify expressions x0..xn
         // make addition (x0,-x1..-xn)
-        Trace.Assert(original.SubTrees.Count() > 1);
-        var simplifiedTrees = original.SubTrees.Select(x => GetSimplifiedTree(x));
+        Trace.Assert(original.Subtrees.Count() > 1);
+        var simplifiedTrees = original.Subtrees.Select(x => GetSimplifiedTree(x));
         return simplifiedTrees.Take(1)
           .Concat(simplifiedTrees.Skip(1).Select(x => Negate(x)))
@@ -307,11 +307,11 @@
 
     private ISymbolicExpressionTreeNode SimplifyAddition(ISymbolicExpressionTreeNode original) {
-      if (original.SubTrees.Count() == 1) {
-        return GetSimplifiedTree(original.GetSubTree(0));
+      if (original.Subtrees.Count() == 1) {
+        return GetSimplifiedTree(original.GetSubtree(0));
       } else {
         // simplify expression x0..xn
         // make addition (x0..xn)
-        Trace.Assert(original.SubTrees.Count() > 1);
-        return original.SubTrees
+        Trace.Assert(original.Subtrees.Count() > 1);
+        return original.Subtrees
           .Select(x => GetSimplifiedTree(x))
           .Aggregate((a, b) => MakeSum(a, b));
@@ -320,47 +320,47 @@
 
     private ISymbolicExpressionTreeNode SimplifyNot(ISymbolicExpressionTreeNode original) {
-      return MakeNot(GetSimplifiedTree(original.GetSubTree(0)));
+      return MakeNot(GetSimplifiedTree(original.GetSubtree(0)));
     }
     private ISymbolicExpressionTreeNode SimplifyOr(ISymbolicExpressionTreeNode original) {
-      return original.SubTrees
+      return original.Subtrees
         .Select(x => GetSimplifiedTree(x))
         .Aggregate((a, b) => MakeOr(a, b));
     }
     private ISymbolicExpressionTreeNode SimplifyAnd(ISymbolicExpressionTreeNode original) {
-      return original.SubTrees
+      return original.Subtrees
         .Select(x => GetSimplifiedTree(x))
         .Aggregate((a, b) => MakeAnd(a, b));
     }
     private ISymbolicExpressionTreeNode SimplifyLessThan(ISymbolicExpressionTreeNode original) {
-      return MakeLessThan(GetSimplifiedTree(original.GetSubTree(0)), GetSimplifiedTree(original.GetSubTree(1)));
+      return MakeLessThan(GetSimplifiedTree(original.GetSubtree(0)), GetSimplifiedTree(original.GetSubtree(1)));
     }
     private ISymbolicExpressionTreeNode SimplifyGreaterThan(ISymbolicExpressionTreeNode original) {
-      return MakeGreaterThan(GetSimplifiedTree(original.GetSubTree(0)), GetSimplifiedTree(original.GetSubTree(1)));
+      return MakeGreaterThan(GetSimplifiedTree(original.GetSubtree(0)), GetSimplifiedTree(original.GetSubtree(1)));
     }
     private ISymbolicExpressionTreeNode SimplifyIfThenElse(ISymbolicExpressionTreeNode original) {
-      return MakeIfThenElse(GetSimplifiedTree(original.GetSubTree(0)), GetSimplifiedTree(original.GetSubTree(1)), GetSimplifiedTree(original.GetSubTree(2)));
+      return MakeIfThenElse(GetSimplifiedTree(original.GetSubtree(0)), GetSimplifiedTree(original.GetSubtree(1)), GetSimplifiedTree(original.GetSubtree(2)));
     }
     private ISymbolicExpressionTreeNode SimplifyTangent(ISymbolicExpressionTreeNode original) {
-      return MakeTangent(GetSimplifiedTree(original.GetSubTree(0)));
+      return MakeTangent(GetSimplifiedTree(original.GetSubtree(0)));
     }
     private ISymbolicExpressionTreeNode SimplifyCosine(ISymbolicExpressionTreeNode original) {
-      return MakeCosine(GetSimplifiedTree(original.GetSubTree(0)));
+      return MakeCosine(GetSimplifiedTree(original.GetSubtree(0)));
     }
     private ISymbolicExpressionTreeNode SimplifySine(ISymbolicExpressionTreeNode original) {
-      return MakeSine(GetSimplifiedTree(original.GetSubTree(0)));
+      return MakeSine(GetSimplifiedTree(original.GetSubtree(0)));
     }
     private ISymbolicExpressionTreeNode SimplifyExp(ISymbolicExpressionTreeNode original) {
-      return MakeExp(GetSimplifiedTree(original.GetSubTree(0)));
+      return MakeExp(GetSimplifiedTree(original.GetSubtree(0)));
     }
 
     private ISymbolicExpressionTreeNode SimplifyLog(ISymbolicExpressionTreeNode original) {
-      return MakeLog(GetSimplifiedTree(original.GetSubTree(0)));
+      return MakeLog(GetSimplifiedTree(original.GetSubtree(0)));
     }
     private ISymbolicExpressionTreeNode SimplifyRoot(ISymbolicExpressionTreeNode original) {
-      return MakeRoot(GetSimplifiedTree(original.GetSubTree(0)), GetSimplifiedTree(original.GetSubTree(1)));
+      return MakeRoot(GetSimplifiedTree(original.GetSubtree(0)), GetSimplifiedTree(original.GetSubtree(1)));
     }
 
     private ISymbolicExpressionTreeNode SimplifyPower(ISymbolicExpressionTreeNode original) {
-      return MakePower(GetSimplifiedTree(original.GetSubTree(0)), GetSimplifiedTree(original.GetSubTree(1)));
+      return MakePower(GetSimplifiedTree(original.GetSubtree(0)), GetSimplifiedTree(original.GetSubtree(1)));
     }
     #endregion
@@ -373,14 +373,14 @@
         else return MakeConstant(1.0);
       } else if (IsNot(t)) {
-        return t.GetSubTree(0);
+        return t.GetSubtree(0);
       } else if (!IsBoolean(t)) {
         var gtNode = gtSymbol.CreateTreeNode();
-        gtNode.AddSubTree(t); gtNode.AddSubTree(MakeConstant(0.0));
+        gtNode.AddSubtree(t); gtNode.AddSubtree(MakeConstant(0.0));
         var notNode = notSymbol.CreateTreeNode();
-        notNode.AddSubTree(gtNode);
+        notNode.AddSubtree(gtNode);
         return notNode;
       } else {
         var notNode = notSymbol.CreateTreeNode();
-        notNode.AddSubTree(t);
+        notNode.AddSubtree(t);
         return notNode;
       }
@@ -406,11 +406,11 @@
           // the constant value has no effect on the result of the boolean condition so we can drop the constant term
           var orNode = orSymbol.CreateTreeNode();
-          orNode.AddSubTree(a);
+          orNode.AddSubtree(a);
           return orNode;
         }
       } else {
         var orNode = orSymbol.CreateTreeNode();
-        orNode.AddSubTree(a);
-        orNode.AddSubTree(b);
+        orNode.AddSubtree(a);
+        orNode.AddSubtree(b);
         return orNode;
       }
@@ -432,5 +432,5 @@
           // the constant value has no effect on the result of the boolean condition so we can drop the constant term
           var andNode = andSymbol.CreateTreeNode();
-          andNode.AddSubTree(a);
+          andNode.AddSubtree(a);
           return andNode;
         } else {
@@ -440,6 +440,6 @@
       } else {
         var andNode = andSymbol.CreateTreeNode();
-        andNode.AddSubTree(a);
-        andNode.AddSubTree(b);
+        andNode.AddSubtree(a);
+        andNode.AddSubtree(b);
         return andNode;
       }
@@ -453,6 +453,6 @@
       } else {
         var ltNode = ltSymbol.CreateTreeNode();
-        ltNode.AddSubTree(leftSide);
-        ltNode.AddSubTree(rightSide);
+        ltNode.AddSubtree(leftSide);
+        ltNode.AddSubtree(rightSide);
         return ltNode;
       }
@@ -466,6 +466,6 @@
       } else {
         var gtNode = gtSymbol.CreateTreeNode();
-        gtNode.AddSubTree(leftSide);
-        gtNode.AddSubTree(rightSide);
+        gtNode.AddSubtree(leftSide);
+        gtNode.AddSubtree(rightSide);
         return gtNode;
       }
@@ -479,12 +479,12 @@
         var ifNode = ifThenElseSymbol.CreateTreeNode();
         if (IsBoolean(condition)) {
-          ifNode.AddSubTree(condition);
+          ifNode.AddSubtree(condition);
         } else {
           var gtNode = gtSymbol.CreateTreeNode();
-          gtNode.AddSubTree(condition); gtNode.AddSubTree(MakeConstant(0.0));
-          ifNode.AddSubTree(gtNode);
-        }
-        ifNode.AddSubTree(trueBranch);
-        ifNode.AddSubTree(falseBranch);
+          gtNode.AddSubtree(condition); gtNode.AddSubtree(MakeConstant(0.0));
+          ifNode.AddSubtree(gtNode);
+        }
+        ifNode.AddSubtree(trueBranch);
+        ifNode.AddSubtree(falseBranch);
         return ifNode;
       }
@@ -497,5 +497,5 @@
       } else {
         var sineNode = sineSymbol.CreateTreeNode();
-        sineNode.AddSubTree(node);
+        sineNode.AddSubtree(node);
         return sineNode;
       }
@@ -507,5 +507,5 @@
       } else {
         var tanNode = tanSymbol.CreateTreeNode();
-        tanNode.AddSubTree(node);
+        tanNode.AddSubtree(node);
         return tanNode;
       }
@@ -517,5 +517,5 @@
       } else {
         var cosNode = cosineSymbol.CreateTreeNode();
-        cosNode.AddSubTree(node);
+        cosNode.AddSubtree(node);
         return cosNode;
       }
@@ -526,12 +526,12 @@
         return MakeConstant(Math.Exp(constT.Value));
       } else if (IsLog(node)) {
-        return node.GetSubTree(0);
+        return node.GetSubtree(0);
       } else if (IsAddition(node)) {
-        return node.SubTrees.Select(s => MakeExp(s)).Aggregate((s, t) => MakeProduct(s, t));
+        return node.Subtrees.Select(s => MakeExp(s)).Aggregate((s, t) => MakeProduct(s, t));
       } else if (IsSubtraction(node)) {
-        return node.SubTrees.Select(s => MakeExp(s)).Aggregate((s, t) => MakeProduct(s, Negate(t)));
+        return node.Subtrees.Select(s => MakeExp(s)).Aggregate((s, t) => MakeProduct(s, Negate(t)));
       } else {
         var expNode = expSymbol.CreateTreeNode();
-        expNode.AddSubTree(node);
+        expNode.AddSubtree(node);
         return expNode;
       }
@@ -542,16 +542,16 @@
         return MakeConstant(Math.Log(constT.Value));
       } else if (IsExp(node)) {
-        return node.GetSubTree(0);
+        return node.GetSubtree(0);
       } else if (IsMultiplication(node)) {
-        return node.SubTrees.Select(s => MakeLog(s)).Aggregate((x, y) => MakeSum(x, y));
+        return node.Subtrees.Select(s => MakeLog(s)).Aggregate((x, y) => MakeSum(x, y));
       } else if (IsDivision(node)) {
         var subtractionNode = subSymbol.CreateTreeNode();
-        foreach (var subTree in node.SubTrees) {
-          subtractionNode.AddSubTree(MakeLog(subTree));
+        foreach (var subtree in node.Subtrees) {
+          subtractionNode.AddSubtree(MakeLog(subtree));
         }
         return subtractionNode;
       } else {
         var logNode = logSymbol.CreateTreeNode();
-        logNode.AddSubTree(node);
+        logNode.AddSubtree(node);
         return logNode;
       }
@@ -573,17 +573,17 @@
         } else if (constBValue < 0) {
           var rootNode = rootSymbol.CreateTreeNode();
-          rootNode.AddSubTree(a);
-          rootNode.AddSubTree(MakeConstant(-1.0 * constBValue));
+          rootNode.AddSubtree(a);
+          rootNode.AddSubtree(MakeConstant(-1.0 * constBValue));
           return MakeFraction(MakeConstant(1.0), rootNode);
         } else {
           var rootNode = rootSymbol.CreateTreeNode();
-          rootNode.AddSubTree(a);
-          rootNode.AddSubTree(MakeConstant(constBValue));
+          rootNode.AddSubtree(a);
+          rootNode.AddSubtree(MakeConstant(constBValue));
           return rootNode;
         }
       } else {
         var rootNode = rootSymbol.CreateTreeNode();
-        rootNode.AddSubTree(a);
-        rootNode.AddSubTree(b);
+        rootNode.AddSubtree(a);
+        rootNode.AddSubtree(b);
         return rootNode;
       }
@@ -605,17 +605,17 @@
         } else if (exponent < 0) {
           var powNode = powSymbol.CreateTreeNode();
-          powNode.AddSubTree(a);
-          powNode.AddSubTree(MakeConstant(-1.0 * exponent));
+          powNode.AddSubtree(a);
+          powNode.AddSubtree(MakeConstant(-1.0 * exponent));
           return MakeFraction(MakeConstant(1.0), powNode);
         } else {
           var powNode = powSymbol.CreateTreeNode();
-          powNode.AddSubTree(a);
-          powNode.AddSubTree(MakeConstant(exponent));
+          powNode.AddSubtree(a);
+          powNode.AddSubtree(MakeConstant(exponent));
           return powNode;
         }
       } else {
         var powNode = powSymbol.CreateTreeNode();
-        powNode.AddSubTree(a);
-        powNode.AddSubTree(b);
+        powNode.AddSubtree(a);
+        powNode.AddSubtree(b);
         return powNode;
       }
@@ -641,5 +641,5 @@
         return MakeConstant(aVar.Weight / bVar.Weight);
       } else if (IsAddition(a) && IsConstant(b)) {
-        return a.SubTrees
+        return a.Subtrees
           .Select(x => GetSimplifiedTree(x))
          .Select(x => MakeFraction(x, b))
@@ -649,23 +649,23 @@
       } else if (IsDivision(a) && IsConstant(b)) {
         // (a1 / a2) / c => (a1 / (a2 * c))
-        Trace.Assert(a.SubTrees.Count() == 2);
-        return MakeFraction(a.GetSubTree(0), MakeProduct(a.GetSubTree(1), b));
+        Trace.Assert(a.Subtrees.Count() == 2);
+        return MakeFraction(a.GetSubtree(0), MakeProduct(a.GetSubtree(1), b));
       } else if (IsDivision(a) && IsDivision(b)) {
         // (a1 / a2) / (b1 / b2) => 
-        Trace.Assert(a.SubTrees.Count() == 2);
-        Trace.Assert(b.SubTrees.Count() == 2);
-        return MakeFraction(MakeProduct(a.GetSubTree(0), b.GetSubTree(1)), MakeProduct(a.GetSubTree(1), b.GetSubTree(0)));
+        Trace.Assert(a.Subtrees.Count() == 2);
+        Trace.Assert(b.Subtrees.Count() == 2);
+        return MakeFraction(MakeProduct(a.GetSubtree(0), b.GetSubtree(1)), MakeProduct(a.GetSubtree(1), b.GetSubtree(0)));
       } else if (IsDivision(a)) {
         // (a1 / a2) / b => (a1 / (a2 * b))
-        Trace.Assert(a.SubTrees.Count() == 2);
-        return MakeFraction(a.GetSubTree(0), MakeProduct(a.GetSubTree(1), b));
+        Trace.Assert(a.Subtrees.Count() == 2);
+        return MakeFraction(a.GetSubtree(0), MakeProduct(a.GetSubtree(1), b));
       } else if (IsDivision(b)) {
         // a / (b1 / b2) => (a * b2) / b1
-        Trace.Assert(b.SubTrees.Count() == 2);
-        return MakeFraction(MakeProduct(a, b.GetSubTree(1)), b.GetSubTree(0));
+        Trace.Assert(b.Subtrees.Count() == 2);
+        return MakeFraction(MakeProduct(a, b.GetSubtree(1)), b.GetSubtree(0));
       } else {
         var div = divSymbol.CreateTreeNode();
-        div.AddSubTree(a);
-        div.AddSubTree(b);
+        div.AddSubtree(a);
+        div.AddSubtree(b);
         return div;
       }
@@ -688,18 +688,18 @@
         var add = addSymbol.CreateTreeNode();
         // add all sub trees except for the last
-        for (int i = 0; i < a.SubTrees.Count() - 1; i++) add.AddSubTree(a.GetSubTree(i));
-        for (int i = 0; i < b.SubTrees.Count() - 1; i++) add.AddSubTree(b.GetSubTree(i));
-        if (IsConstant(a.SubTrees.Last()) && IsConstant(b.SubTrees.Last())) {
-          add.AddSubTree(MakeSum(a.SubTrees.Last(), b.SubTrees.Last()));
-        } else if (IsConstant(a.SubTrees.Last())) {
-          add.AddSubTree(b.SubTrees.Last());
-          add.AddSubTree(a.SubTrees.Last());
-        } else {
-          add.AddSubTree(a.SubTrees.Last());
-          add.AddSubTree(b.SubTrees.Last());
+        for (int i = 0; i < a.Subtrees.Count() - 1; i++) add.AddSubtree(a.GetSubtree(i));
+        for (int i = 0; i < b.Subtrees.Count() - 1; i++) add.AddSubtree(b.GetSubtree(i));
+        if (IsConstant(a.Subtrees.Last()) && IsConstant(b.Subtrees.Last())) {
+          add.AddSubtree(MakeSum(a.Subtrees.Last(), b.Subtrees.Last()));
+        } else if (IsConstant(a.Subtrees.Last())) {
+          add.AddSubtree(b.Subtrees.Last());
+          add.AddSubtree(a.Subtrees.Last());
+        } else {
+          add.AddSubtree(a.Subtrees.Last());
+          add.AddSubtree(b.Subtrees.Last());
         }
         MergeVariablesInSum(add);
-        if (add.SubTrees.Count() == 1) {
-          return add.GetSubTree(0);
+        if (add.Subtrees.Count() == 1) {
+          return add.GetSubtree(0);
         } else {
           return add;
@@ -711,10 +711,10 @@
         var add = addSymbol.CreateTreeNode();
         // add all sub trees except for the last
-        for (int i = 0; i < a.SubTrees.Count() - 1; i++) add.AddSubTree(a.GetSubTree(i));
-        if (IsConstant(a.SubTrees.Last()))
-          add.AddSubTree(MakeSum(a.SubTrees.Last(), b));
+        for (int i = 0; i < a.Subtrees.Count() - 1; i++) add.AddSubtree(a.GetSubtree(i));
+        if (IsConstant(a.Subtrees.Last()))
+          add.AddSubtree(MakeSum(a.Subtrees.Last(), b));
         else {
-          add.AddSubTree(a.SubTrees.Last());
-          add.AddSubTree(b);
+          add.AddSubtree(a.Subtrees.Last());
+          add.AddSubtree(b);
         }
         return add;
@@ -722,11 +722,11 @@
         // a is already an addition => append b
         var add = addSymbol.CreateTreeNode();
-        add.AddSubTree(b);
-        foreach (var subTree in a.SubTrees) {
-          add.AddSubTree(subTree);
+        add.AddSubtree(b);
+        foreach (var subtree in a.Subtrees) {
+          add.AddSubtree(subtree);
         }
         MergeVariablesInSum(add);
-        if (add.SubTrees.Count() == 1) {
-          return add.GetSubTree(0);
+        if (add.Subtrees.Count() == 1) {
+          return add.GetSubtree(0);
         } else {
           return add;
@@ -734,9 +734,9 @@
       } else {
         var add = addSymbol.CreateTreeNode();
-        add.AddSubTree(a);
-        add.AddSubTree(b);
+        add.AddSubtree(a);
+        add.AddSubtree(b);
         MergeVariablesInSum(add);
-        if (add.SubTrees.Count() == 1) {
-          return add.GetSubTree(0);
+        if (add.Subtrees.Count() == 1) {
+          return add.GetSubtree(0);
         } else {
           return add;
@@ -748,11 +748,11 @@
     // possible improvement: combine sums of products where the products only reference the same variable
     private void MergeVariablesInSum(ISymbolicExpressionTreeNode sum) {
-      var subtrees = new List<ISymbolicExpressionTreeNode>(sum.SubTrees);
-      while (sum.SubTrees.Count() > 0) sum.RemoveSubTree(0);
+      var subtrees = new List<ISymbolicExpressionTreeNode>(sum.Subtrees);
+      while (sum.Subtrees.Count() > 0) sum.RemoveSubtree(0);
       var groupedVarNodes = from node in subtrees.OfType<VariableTreeNode>()
                             let lag = (node is LaggedVariableTreeNode) ? ((LaggedVariableTreeNode)node).Lag : 0
                             group node by node.VariableName + lag into g
                             select g;
-      var unchangedSubTrees = subtrees.Where(t => !(t is VariableTreeNode));
+      var unchangedSubtrees = subtrees.Where(t => !(t is VariableTreeNode));
 
       foreach (var variableNodeGroup in groupedVarNodes) {
@@ -760,8 +760,8 @@
         var representative = variableNodeGroup.First();
         representative.Weight = weightSum;
-        sum.AddSubTree(representative);
-      }
-      foreach (var unchangedSubtree in unchangedSubTrees)
-        sum.AddSubTree(unchangedSubtree);
+        sum.AddSubtree(representative);
+      }
+      foreach (var unchangedSubtree in unchangedSubtrees)
+        sum.AddSubtree(unchangedSubtree);
     }
 
@@ -784,23 +784,23 @@
       } else if (IsConstant(b) && IsAddition(a)) {
         // multiply constants into additions
-        return a.SubTrees.Select(x => MakeProduct(x, b)).Aggregate((c, d) => MakeSum(c, d));
+        return a.Subtrees.Select(x => MakeProduct(x, b)).Aggregate((c, d) => MakeSum(c, d));
       } else if (IsDivision(a) && IsDivision(b)) {
         // (a1 / a2) * (b1 / b2) => (a1 * b1) / (a2 * b2)
-        Trace.Assert(a.SubTrees.Count() == 2);
-        Trace.Assert(b.SubTrees.Count() == 2);
-        return MakeFraction(MakeProduct(a.GetSubTree(0), b.GetSubTree(0)), MakeProduct(a.GetSubTree(1), b.GetSubTree(1)));
+        Trace.Assert(a.Subtrees.Count() == 2);
+        Trace.Assert(b.Subtrees.Count() == 2);
+        return MakeFraction(MakeProduct(a.GetSubtree(0), b.GetSubtree(0)), MakeProduct(a.GetSubtree(1), b.GetSubtree(1)));
       } else if (IsDivision(a)) {
         // (a1 / a2) * b => (a1 * b) / a2
-        Trace.Assert(a.SubTrees.Count() == 2);
-        return MakeFraction(MakeProduct(a.GetSubTree(0), b), a.GetSubTree(1));
+        Trace.Assert(a.Subtrees.Count() == 2);
+        return MakeFraction(MakeProduct(a.GetSubtree(0), b), a.GetSubtree(1));
       } else if (IsDivision(b)) {
         // a * (b1 / b2) => (b1 * a) / b2
-        Trace.Assert(b.SubTrees.Count() == 2);
-        return MakeFraction(MakeProduct(b.GetSubTree(0), a), b.GetSubTree(1));
+        Trace.Assert(b.Subtrees.Count() == 2);
+        return MakeFraction(MakeProduct(b.GetSubtree(0), a), b.GetSubtree(1));
       } else if (IsMultiplication(a) && IsMultiplication(b)) {
         // merge multiplications (make sure constants are merged)
         var mul = mulSymbol.CreateTreeNode();
-        for (int i = 0; i < a.SubTrees.Count(); i++) mul.AddSubTree(a.GetSubTree(i));
-        for (int i = 0; i < b.SubTrees.Count(); i++) mul.AddSubTree(b.GetSubTree(i));
+        for (int i = 0; i < a.Subtrees.Count(); i++) mul.AddSubtree(a.GetSubtree(i));
+        for (int i = 0; i < b.Subtrees.Count(); i++) mul.AddSubtree(b.GetSubtree(i));
         MergeVariablesAndConstantsInProduct(mul);
         return mul;
@@ -809,11 +809,11 @@
       } else if (IsMultiplication(a)) {
         // a is already an multiplication => append b
-        a.AddSubTree(b);
+        a.AddSubtree(b);
         MergeVariablesAndConstantsInProduct(a);
         return a;
       } else {
         var mul = mulSymbol.CreateTreeNode();
-        mul.AddSubTree(a);
-        mul.AddSubTree(b);
+        mul.AddSubtree(a);
+        mul.AddSubtree(b);
         MergeVariablesAndConstantsInProduct(mul);
         return mul;
@@ -842,6 +842,6 @@
     // helper to combine the constant factors in products and to combine variables (powers of 2, 3...)
     private void MergeVariablesAndConstantsInProduct(ISymbolicExpressionTreeNode prod) {
-      var subtrees = new List<ISymbolicExpressionTreeNode>(prod.SubTrees);
-      while (prod.SubTrees.Count() > 0) prod.RemoveSubTree(0);
+      var subtrees = new List<ISymbolicExpressionTreeNode>(prod.Subtrees);
+      while (prod.Subtrees.Count() > 0) prod.RemoveSubtree(0);
       var groupedVarNodes = from node in subtrees.OfType<VariableTreeNode>()
                             let lag = (node is LaggedVariableTreeNode) ? ((LaggedVariableTreeNode)node).Lag : 0
@@ -856,5 +856,5 @@
                             .Aggregate((c1, c2) => c1 * c2);
 
-      var unchangedSubTrees = from tree in subtrees
+      var unchangedSubtrees = from tree in subtrees
                               where !(tree is VariableTreeNode)
                               where !(tree is ConstantTreeNode)
@@ -867,17 +867,17 @@
           var poly = mulSymbol.CreateTreeNode();
           for (int p = 0; p < variableNodeGroup.Count(); p++) {
-            poly.AddSubTree((ISymbolicExpressionTreeNode)representative.Clone());
+            poly.AddSubtree((ISymbolicExpressionTreeNode)representative.Clone());
           }
-          prod.AddSubTree(poly);
-        } else {
-          prod.AddSubTree(representative);
-        }
-      }
-
-      foreach (var unchangedSubtree in unchangedSubTrees)
-        prod.AddSubTree(unchangedSubtree);
+          prod.AddSubtree(poly);
+        } else {
+          prod.AddSubtree(representative);
+        }
+      }
+
+      foreach (var unchangedSubtree in unchangedSubtrees)
+        prod.AddSubtree(unchangedSubtree);
 
       if (!constantProduct.IsAlmost(1.0)) {
-        prod.AddSubTree(MakeConstant(constantProduct));
+        prod.AddSubtree(MakeConstant(constantProduct));
       }
     }
@@ -898,13 +898,13 @@
       } else if (IsAddition(x)) {
         // (x0 + x1 + .. + xn) * -1 => (-x0 + -x1 + .. + -xn)        
-        List<ISymbolicExpressionTreeNode> subTrees = new List<ISymbolicExpressionTreeNode>(x.SubTrees);
-        while (x.SubTrees.Count() > 0) x.RemoveSubTree(0);
-        foreach (var subTree in subTrees) {
-          x.AddSubTree(Negate(subTree));
+        List<ISymbolicExpressionTreeNode> subtrees = new List<ISymbolicExpressionTreeNode>(x.Subtrees);
+        while (x.Subtrees.Count() > 0) x.RemoveSubtree(0);
+        foreach (var subtree in subtrees) {
+          x.AddSubtree(Negate(subtree));
         }
       } else if (IsMultiplication(x) || IsDivision(x)) {
         // x0 * x1 * .. * xn * -1 => x0 * x1 * .. * -xn
-        x.RemoveSubTree(x.SubTrees.Count() - 1);
-        x.AddSubTree(Negate(x.SubTrees.Last())); // last is maybe a constant, prefer to negate the constant
+        x.RemoveSubtree(x.Subtrees.Count() - 1);
+        x.AddSubtree(Negate(x.Subtrees.Last())); // last is maybe a constant, prefer to negate the constant
       } else {
         // any other function
@@ -924,6 +924,6 @@
         return MakeConstant(1.0 / ((ConstantTreeNode)x).Value);
       } else if (IsDivision(x)) {
-        Trace.Assert(x.SubTrees.Count() == 2);
-        return MakeFraction(x.GetSubTree(1), x.GetSubTree(0));
+        Trace.Assert(x.Subtrees.Count() == 2);
+        return MakeFraction(x.GetSubtree(1), x.GetSubtree(0));
       } else {
         // any other function
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisProblem.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisProblem.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisProblem.cs	(revision 5733)
@@ -38,5 +38,5 @@
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
   [StorableClass]
-  public abstract class SymbolicDataAnalysisProblem<T, U, V> : HeuristicOptimizationProblem<U, V>, ISymbolicDataAnalysisProblem, IStorableContent
+  public abstract class SymbolicDataAnalysisProblem<T, U, V> : HeuristicOptimizationProblem<U, V>, IDataAnalysisProblem, IStorableContent
     where T : class,IDataAnalysisProblemData
     where U : class, ISymbolicDataAnalysisEvaluator<T>
@@ -50,4 +50,7 @@
     private const string MaximumFunctionDefinitionsParameterName = "MaximumFunctionDefinitions";
     private const string MaximumFunctionArgumentsParameterName = "MaximumFunctionArguments";
+    private const string RelativeNumberOfEvaluatedSamples = "RelativeNumberOfEvaluatedSamples";
+    private const string FitnessCalculationPartitionParameterName = "FitnessCalculationPartition";
+    private const string ModelSelectionPartitionParamterName = "ModelSelectionPartition";
 
     private const string ProblemDataParameterDescription = "";
Index: /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tests/SymbolicExpressionImporter.cs
===================================================================
--- /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tests/SymbolicExpressionImporter.cs	(revision 5732)
+++ /branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Tests/SymbolicExpressionImporter.cs	(revision 5733)
@@ -76,6 +76,6 @@
       } else {
         // only a main branch was given => insert the main branch into the default tree template
-        root.AddSubTree(start);
-        start.AddSubTree(mainBranch);
+        root.AddSubtree(start);
+        start.AddSubtree(mainBranch);
       }
       return new SymbolicExpressionTree(root);
@@ -99,5 +99,5 @@
           tree = ParseDefun(tokens);
           while (!tokens.Peek().Equals(Token.RPAR)) {
-            tree.AddSubTree(ParseSexp(tokens));
+            tree.AddSubtree(ParseSexp(tokens));
           }
         } else if (tokens.Peek().StringValue.StartsWith(ARGSTART)) {
@@ -106,5 +106,5 @@
           tree = ParseInvoke(tokens);
           while (!tokens.Peek().Equals(Token.RPAR)) {
-            tree.AddSubTree(ParseSexp(tokens));
+            tree.AddSubtree(ParseSexp(tokens));
           }
         } else {
@@ -112,5 +112,5 @@
           tree = CreateTree(curToken);
           while (!tokens.Peek().Equals(Token.RPAR)) {
-            tree.AddSubTree(ParseSexp(tokens));
+            tree.AddSubtree(ParseSexp(tokens));
           }
         }
