Index: trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/TreeSimplifier.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/TreeSimplifier.cs	(revision 14948)
+++ trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/TreeSimplifier.cs	(revision 14949)
@@ -33,28 +33,31 @@
   /// </summary>
   public class TreeSimplifier {
-    private readonly Addition addSymbol = new Addition();
-    private readonly Multiplication mulSymbol = new Multiplication();
-    private readonly Division divSymbol = new Division();
-    private readonly Constant constSymbol = new Constant();
-    private readonly Logarithm logSymbol = new Logarithm();
-    private readonly Exponential expSymbol = new Exponential();
-    private readonly Root rootSymbol = new Root();
-    private readonly Square sqrSymbol = new Square();
-    private readonly SquareRoot sqrtSymbol = new SquareRoot();
-    private readonly Power powSymbol = new Power();
-    private readonly Sine sineSymbol = new Sine();
-    private readonly Cosine cosineSymbol = new Cosine();
-    private readonly Tangent tanSymbol = new Tangent();
-    private readonly IfThenElse ifThenElseSymbol = new IfThenElse();
-    private readonly And andSymbol = new And();
-    private readonly Or orSymbol = new Or();
-    private readonly Not notSymbol = new Not();
-    private readonly GreaterThan gtSymbol = new GreaterThan();
-    private readonly LessThan ltSymbol = new LessThan();
-    private readonly Integral integralSymbol = new Integral();
-    private readonly LaggedVariable laggedVariableSymbol = new LaggedVariable();
-    private readonly TimeLag timeLagSymbol = new TimeLag();
-
-    public ISymbolicExpressionTree Simplify(ISymbolicExpressionTree originalTree) {
+    private static readonly Addition addSymbol = new Addition();
+    private static readonly Multiplication mulSymbol = new Multiplication();
+    private static readonly Division divSymbol = new Division();
+    private static readonly Constant constSymbol = new Constant();
+    private static readonly Logarithm logSymbol = new Logarithm();
+    private static readonly Exponential expSymbol = new Exponential();
+    private static readonly Root rootSymbol = new Root();
+    private static readonly Square sqrSymbol = new Square();
+    private static readonly SquareRoot sqrtSymbol = new SquareRoot();
+    private static readonly Power powSymbol = new Power();
+    private static readonly Sine sineSymbol = new Sine();
+    private static readonly Cosine cosineSymbol = new Cosine();
+    private static readonly Tangent tanSymbol = new Tangent();
+    private static readonly IfThenElse ifThenElseSymbol = new IfThenElse();
+    private static readonly And andSymbol = new And();
+    private static readonly Or orSymbol = new Or();
+    private static readonly Not notSymbol = new Not();
+    private static readonly GreaterThan gtSymbol = new GreaterThan();
+    private static readonly LessThan ltSymbol = new LessThan();
+    private static readonly Integral integralSymbol = new Integral();
+    private static readonly LaggedVariable laggedVariableSymbol = new LaggedVariable();
+    private static readonly TimeLag timeLagSymbol = new TimeLag();
+
+    [Obsolete("Use static method TreeSimplifier.Simplify instead")]
+    public TreeSimplifier() { }
+
+    public static ISymbolicExpressionTree Simplify(ISymbolicExpressionTree originalTree) {
       var clone = (ISymbolicExpressionTreeNode)originalTree.Root.Clone();
       // macro expand (initially no argument trees)
@@ -66,5 +69,5 @@
       // check that each node is only referenced once
       var nodes = rootNode.IterateNodesPrefix().ToArray();
-      foreach(var n in nodes) if(nodes.Count(ni => ni == n) > 1) throw new InvalidOperationException();
+      foreach (var n in nodes) if (nodes.Count(ni => ni == n) > 1) throw new InvalidOperationException();
 #endif
       return new SymbolicExpressionTree(rootNode);
@@ -72,5 +75,5 @@
 
     // the argumentTrees list contains already expanded trees used as arguments for invocations
-    private ISymbolicExpressionTreeNode MacroExpand(ISymbolicExpressionTreeNode root, ISymbolicExpressionTreeNode node,
+    private static ISymbolicExpressionTreeNode MacroExpand(ISymbolicExpressionTreeNode root, ISymbolicExpressionTreeNode node,
       IList<ISymbolicExpressionTreeNode> argumentTrees) {
       List<ISymbolicExpressionTreeNode> subtrees = new List<ISymbolicExpressionTreeNode>(node.Subtrees);
@@ -97,5 +100,5 @@
     }
 
-    private ISymbolicExpressionTreeNode FindFunctionDefinition(ISymbolicExpressionTreeNode root, string functionName) {
+    private static ISymbolicExpressionTreeNode FindFunctionDefinition(ISymbolicExpressionTreeNode root, string functionName) {
       foreach (var subtree in root.Subtrees.OfType<DefunTreeNode>()) {
         if (subtree.FunctionName == functionName) return subtree.GetSubtree(0);
@@ -108,89 +111,89 @@
 
     // arithmetic
-    private bool IsDivision(ISymbolicExpressionTreeNode node) {
+    private static bool IsDivision(ISymbolicExpressionTreeNode node) {
       return node.Symbol is Division;
     }
 
-    private bool IsMultiplication(ISymbolicExpressionTreeNode node) {
+    private static bool IsMultiplication(ISymbolicExpressionTreeNode node) {
       return node.Symbol is Multiplication;
     }
 
-    private bool IsSubtraction(ISymbolicExpressionTreeNode node) {
+    private static bool IsSubtraction(ISymbolicExpressionTreeNode node) {
       return node.Symbol is Subtraction;
     }
 
-    private bool IsAddition(ISymbolicExpressionTreeNode node) {
+    private static bool IsAddition(ISymbolicExpressionTreeNode node) {
       return node.Symbol is Addition;
     }
 
-    private bool IsAverage(ISymbolicExpressionTreeNode node) {
+    private static bool IsAverage(ISymbolicExpressionTreeNode node) {
       return node.Symbol is Average;
     }
 
     // exponential
-    private bool IsLog(ISymbolicExpressionTreeNode node) {
+    private static bool IsLog(ISymbolicExpressionTreeNode node) {
       return node.Symbol is Logarithm;
     }
 
-    private bool IsExp(ISymbolicExpressionTreeNode node) {
+    private static bool IsExp(ISymbolicExpressionTreeNode node) {
       return node.Symbol is Exponential;
     }
 
-    private bool IsRoot(ISymbolicExpressionTreeNode node) {
+    private static bool IsRoot(ISymbolicExpressionTreeNode node) {
       return node.Symbol is Root;
     }
 
-    private bool IsSquare(ISymbolicExpressionTreeNode node) {
+    private static bool IsSquare(ISymbolicExpressionTreeNode node) {
       return node.Symbol is Square;
     }
 
-    private bool IsSquareRoot(ISymbolicExpressionTreeNode node) {
+    private static bool IsSquareRoot(ISymbolicExpressionTreeNode node) {
       return node.Symbol is SquareRoot;
     }
 
-    private bool IsPower(ISymbolicExpressionTreeNode node) {
+    private static bool IsPower(ISymbolicExpressionTreeNode node) {
       return node.Symbol is Power;
     }
 
     // trigonometric
-    private bool IsSine(ISymbolicExpressionTreeNode node) {
+    private static bool IsSine(ISymbolicExpressionTreeNode node) {
       return node.Symbol is Sine;
     }
 
-    private bool IsCosine(ISymbolicExpressionTreeNode node) {
+    private static bool IsCosine(ISymbolicExpressionTreeNode node) {
       return node.Symbol is Cosine;
     }
 
-    private bool IsTangent(ISymbolicExpressionTreeNode node) {
+    private static bool IsTangent(ISymbolicExpressionTreeNode node) {
       return node.Symbol is Tangent;
     }
 
     // boolean
-    private bool IsIfThenElse(ISymbolicExpressionTreeNode node) {
+    private static bool IsIfThenElse(ISymbolicExpressionTreeNode node) {
       return node.Symbol is IfThenElse;
     }
 
-    private bool IsAnd(ISymbolicExpressionTreeNode node) {
+    private static bool IsAnd(ISymbolicExpressionTreeNode node) {
       return node.Symbol is And;
     }
 
-    private bool IsOr(ISymbolicExpressionTreeNode node) {
+    private static bool IsOr(ISymbolicExpressionTreeNode node) {
       return node.Symbol is Or;
     }
 
-    private bool IsNot(ISymbolicExpressionTreeNode node) {
+    private static bool IsNot(ISymbolicExpressionTreeNode node) {
       return node.Symbol is Not;
     }
 
     // comparison
-    private bool IsGreaterThan(ISymbolicExpressionTreeNode node) {
+    private static bool IsGreaterThan(ISymbolicExpressionTreeNode node) {
       return node.Symbol is GreaterThan;
     }
 
-    private bool IsLessThan(ISymbolicExpressionTreeNode node) {
+    private static bool IsLessThan(ISymbolicExpressionTreeNode node) {
       return node.Symbol is LessThan;
     }
 
-    private bool IsBoolean(ISymbolicExpressionTreeNode node) {
+    private static bool IsBoolean(ISymbolicExpressionTreeNode node) {
       return
         node.Symbol is GreaterThan ||
@@ -201,30 +204,30 @@
 
     // terminals
-    private bool IsVariable(ISymbolicExpressionTreeNode node) {
+    private static bool IsVariable(ISymbolicExpressionTreeNode node) {
       return node.Symbol is Variable;
     }
 
-    private bool IsVariableBase(ISymbolicExpressionTreeNode node) {
+    private static bool IsVariableBase(ISymbolicExpressionTreeNode node) {
       return node is VariableTreeNodeBase;
     }
 
-    private bool IsFactor(ISymbolicExpressionTreeNode node) {
+    private static bool IsFactor(ISymbolicExpressionTreeNode node) {
       return node is FactorVariableTreeNode;
     }
 
-    private bool IsBinFactor(ISymbolicExpressionTreeNode node) {
+    private static bool IsBinFactor(ISymbolicExpressionTreeNode node) {
       return node is BinaryFactorVariableTreeNode;
     }
 
-    private bool IsConstant(ISymbolicExpressionTreeNode node) {
+    private static bool IsConstant(ISymbolicExpressionTreeNode node) {
       return node.Symbol is Constant;
     }
 
     // dynamic
-    private bool IsTimeLag(ISymbolicExpressionTreeNode node) {
+    private static bool IsTimeLag(ISymbolicExpressionTreeNode node) {
       return node.Symbol is TimeLag;
     }
 
-    private bool IsIntegral(ISymbolicExpressionTreeNode node) {
+    private static bool IsIntegral(ISymbolicExpressionTreeNode node) {
       return node.Symbol is Integral;
     }
@@ -237,5 +240,5 @@
     /// <param name="original"></param>
     /// <returns></returns>
-    public ISymbolicExpressionTreeNode GetSimplifiedTree(ISymbolicExpressionTreeNode original) {
+    public static ISymbolicExpressionTreeNode GetSimplifiedTree(ISymbolicExpressionTreeNode original) {
       if (IsConstant(original) || IsVariableBase(original)) {
         return (ISymbolicExpressionTreeNode)original.Clone();
@@ -291,5 +294,5 @@
     #region specific simplification routines
 
-    private ISymbolicExpressionTreeNode SimplifyAny(ISymbolicExpressionTreeNode original) {
+    private static ISymbolicExpressionTreeNode SimplifyAny(ISymbolicExpressionTreeNode original) {
       // can't simplify this function but simplify all subtrees 
       List<ISymbolicExpressionTreeNode> subtrees = new List<ISymbolicExpressionTreeNode>(original.Subtrees);
@@ -310,10 +313,10 @@
     }
 
-    private ISymbolicExpressionTreeNode SimplifyConstantExpression(ISymbolicExpressionTreeNode original) {
+    private static ISymbolicExpressionTreeNode SimplifyConstantExpression(ISymbolicExpressionTreeNode original) {
       // not yet implemented
       return original;
     }
 
-    private ISymbolicExpressionTreeNode SimplifyAverage(ISymbolicExpressionTreeNode original) {
+    private static ISymbolicExpressionTreeNode SimplifyAverage(ISymbolicExpressionTreeNode original) {
       if (original.Subtrees.Count() == 1) {
         return GetSimplifiedTree(original.GetSubtree(0));
@@ -328,5 +331,5 @@
     }
 
-    private ISymbolicExpressionTreeNode SimplifyDivision(ISymbolicExpressionTreeNode original) {
+    private static ISymbolicExpressionTreeNode SimplifyDivision(ISymbolicExpressionTreeNode original) {
       if (original.Subtrees.Count() == 1) {
         return Invert(GetSimplifiedTree(original.GetSubtree(0)));
@@ -343,5 +346,5 @@
     }
 
-    private ISymbolicExpressionTreeNode SimplifyMultiplication(ISymbolicExpressionTreeNode original) {
+    private static ISymbolicExpressionTreeNode SimplifyMultiplication(ISymbolicExpressionTreeNode original) {
       if (original.Subtrees.Count() == 1) {
         return GetSimplifiedTree(original.GetSubtree(0));
@@ -353,5 +356,5 @@
     }
 
-    private ISymbolicExpressionTreeNode SimplifySubtraction(ISymbolicExpressionTreeNode original) {
+    private static ISymbolicExpressionTreeNode SimplifySubtraction(ISymbolicExpressionTreeNode original) {
       if (original.Subtrees.Count() == 1) {
         return Negate(GetSimplifiedTree(original.GetSubtree(0)));
@@ -365,5 +368,5 @@
     }
 
-    private ISymbolicExpressionTreeNode SimplifyAddition(ISymbolicExpressionTreeNode original) {
+    private static ISymbolicExpressionTreeNode SimplifyAddition(ISymbolicExpressionTreeNode original) {
       if (original.Subtrees.Count() == 1) {
         return GetSimplifiedTree(original.GetSubtree(0));
@@ -377,9 +380,9 @@
     }
 
-    private ISymbolicExpressionTreeNode SimplifyNot(ISymbolicExpressionTreeNode original) {
+    private static ISymbolicExpressionTreeNode SimplifyNot(ISymbolicExpressionTreeNode original) {
       return MakeNot(GetSimplifiedTree(original.GetSubtree(0)));
     }
 
-    private ISymbolicExpressionTreeNode SimplifyOr(ISymbolicExpressionTreeNode original) {
+    private static ISymbolicExpressionTreeNode SimplifyOr(ISymbolicExpressionTreeNode original) {
       return original.Subtrees
         .Select(GetSimplifiedTree)
@@ -387,5 +390,5 @@
     }
 
-    private ISymbolicExpressionTreeNode SimplifyAnd(ISymbolicExpressionTreeNode original) {
+    private static ISymbolicExpressionTreeNode SimplifyAnd(ISymbolicExpressionTreeNode original) {
       return original.Subtrees
         .Select(GetSimplifiedTree)
@@ -393,54 +396,54 @@
     }
 
-    private ISymbolicExpressionTreeNode SimplifyLessThan(ISymbolicExpressionTreeNode original) {
+    private static ISymbolicExpressionTreeNode SimplifyLessThan(ISymbolicExpressionTreeNode original) {
       return MakeLessThan(GetSimplifiedTree(original.GetSubtree(0)), GetSimplifiedTree(original.GetSubtree(1)));
     }
 
-    private ISymbolicExpressionTreeNode SimplifyGreaterThan(ISymbolicExpressionTreeNode original) {
+    private static ISymbolicExpressionTreeNode SimplifyGreaterThan(ISymbolicExpressionTreeNode original) {
       return MakeGreaterThan(GetSimplifiedTree(original.GetSubtree(0)), GetSimplifiedTree(original.GetSubtree(1)));
     }
 
-    private ISymbolicExpressionTreeNode SimplifyIfThenElse(ISymbolicExpressionTreeNode original) {
+    private static ISymbolicExpressionTreeNode SimplifyIfThenElse(ISymbolicExpressionTreeNode original) {
       return MakeIfThenElse(GetSimplifiedTree(original.GetSubtree(0)), GetSimplifiedTree(original.GetSubtree(1)),
         GetSimplifiedTree(original.GetSubtree(2)));
     }
 
-    private ISymbolicExpressionTreeNode SimplifyTangent(ISymbolicExpressionTreeNode original) {
+    private static ISymbolicExpressionTreeNode SimplifyTangent(ISymbolicExpressionTreeNode original) {
       return MakeTangent(GetSimplifiedTree(original.GetSubtree(0)));
     }
 
-    private ISymbolicExpressionTreeNode SimplifyCosine(ISymbolicExpressionTreeNode original) {
+    private static ISymbolicExpressionTreeNode SimplifyCosine(ISymbolicExpressionTreeNode original) {
       return MakeCosine(GetSimplifiedTree(original.GetSubtree(0)));
     }
 
-    private ISymbolicExpressionTreeNode SimplifySine(ISymbolicExpressionTreeNode original) {
+    private static ISymbolicExpressionTreeNode SimplifySine(ISymbolicExpressionTreeNode original) {
       return MakeSine(GetSimplifiedTree(original.GetSubtree(0)));
     }
 
-    private ISymbolicExpressionTreeNode SimplifyExp(ISymbolicExpressionTreeNode original) {
+    private static ISymbolicExpressionTreeNode SimplifyExp(ISymbolicExpressionTreeNode original) {
       return MakeExp(GetSimplifiedTree(original.GetSubtree(0)));
     }
 
-    private ISymbolicExpressionTreeNode SimplifySquare(ISymbolicExpressionTreeNode original) {
+    private static ISymbolicExpressionTreeNode SimplifySquare(ISymbolicExpressionTreeNode original) {
       return MakeSquare(GetSimplifiedTree(original.GetSubtree(0)));
     }
 
-    private ISymbolicExpressionTreeNode SimplifySquareRoot(ISymbolicExpressionTreeNode original) {
+    private static ISymbolicExpressionTreeNode SimplifySquareRoot(ISymbolicExpressionTreeNode original) {
       return MakeSquareRoot(GetSimplifiedTree(original.GetSubtree(0)));
     }
 
-    private ISymbolicExpressionTreeNode SimplifyLog(ISymbolicExpressionTreeNode original) {
+    private static ISymbolicExpressionTreeNode SimplifyLog(ISymbolicExpressionTreeNode original) {
       return MakeLog(GetSimplifiedTree(original.GetSubtree(0)));
     }
 
-    private ISymbolicExpressionTreeNode SimplifyRoot(ISymbolicExpressionTreeNode original) {
+    private static ISymbolicExpressionTreeNode SimplifyRoot(ISymbolicExpressionTreeNode original) {
       return MakeRoot(GetSimplifiedTree(original.GetSubtree(0)), GetSimplifiedTree(original.GetSubtree(1)));
     }
 
-    private ISymbolicExpressionTreeNode SimplifyPower(ISymbolicExpressionTreeNode original) {
+    private static ISymbolicExpressionTreeNode SimplifyPower(ISymbolicExpressionTreeNode original) {
       return MakePower(GetSimplifiedTree(original.GetSubtree(0)), GetSimplifiedTree(original.GetSubtree(1)));
     }
 
-    private ISymbolicExpressionTreeNode SimplifyTimeLag(ISymbolicExpressionTreeNode original) {
+    private static ISymbolicExpressionTreeNode SimplifyTimeLag(ISymbolicExpressionTreeNode original) {
       var laggedTreeNode = original as ILaggedTreeNode;
       var simplifiedSubtree = GetSimplifiedTree(original.GetSubtree(0));
@@ -452,5 +455,5 @@
     }
 
-    private ISymbolicExpressionTreeNode SimplifyIntegral(ISymbolicExpressionTreeNode original) {
+    private static ISymbolicExpressionTreeNode SimplifyIntegral(ISymbolicExpressionTreeNode original) {
       var laggedTreeNode = original as ILaggedTreeNode;
       var simplifiedSubtree = GetSimplifiedTree(original.GetSubtree(0));
@@ -466,5 +469,5 @@
     #region low level tree restructuring
 
-    private ISymbolicExpressionTreeNode MakeTimeLag(ISymbolicExpressionTreeNode subtree, int lag) {
+    private static ISymbolicExpressionTreeNode MakeTimeLag(ISymbolicExpressionTreeNode subtree, int lag) {
       if (lag == 0) return subtree;
       if (IsConstant(subtree)) return subtree;
@@ -475,5 +478,5 @@
     }
 
-    private ISymbolicExpressionTreeNode MakeIntegral(ISymbolicExpressionTreeNode subtree, int lag) {
+    private static ISymbolicExpressionTreeNode MakeIntegral(ISymbolicExpressionTreeNode subtree, int lag) {
       if (lag == 0) return subtree;
       else if (lag == -1 || lag == 1) {
@@ -487,5 +490,5 @@
     }
 
-    private ISymbolicExpressionTreeNode MakeNot(ISymbolicExpressionTreeNode t) {
+    private static ISymbolicExpressionTreeNode MakeNot(ISymbolicExpressionTreeNode t) {
       if (IsConstant(t)) {
         var constNode = t as ConstantTreeNode;
@@ -508,5 +511,5 @@
     }
 
-    private ISymbolicExpressionTreeNode MakeOr(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
+    private static ISymbolicExpressionTreeNode MakeOr(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
       if (IsConstant(a) && IsConstant(b)) {
         var constA = a as ConstantTreeNode;
@@ -538,5 +541,5 @@
     }
 
-    private ISymbolicExpressionTreeNode MakeAnd(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
+    private static ISymbolicExpressionTreeNode MakeAnd(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
       if (IsConstant(a) && IsConstant(b)) {
         var constA = a as ConstantTreeNode;
@@ -568,5 +571,5 @@
     }
 
-    private ISymbolicExpressionTreeNode MakeLessThan(ISymbolicExpressionTreeNode leftSide,
+    private static ISymbolicExpressionTreeNode MakeLessThan(ISymbolicExpressionTreeNode leftSide,
       ISymbolicExpressionTreeNode rightSide) {
       if (IsConstant(leftSide) && IsConstant(rightSide)) {
@@ -583,5 +586,5 @@
     }
 
-    private ISymbolicExpressionTreeNode MakeGreaterThan(ISymbolicExpressionTreeNode leftSide,
+    private static ISymbolicExpressionTreeNode MakeGreaterThan(ISymbolicExpressionTreeNode leftSide,
       ISymbolicExpressionTreeNode rightSide) {
       if (IsConstant(leftSide) && IsConstant(rightSide)) {
@@ -598,5 +601,5 @@
     }
 
-    private ISymbolicExpressionTreeNode MakeIfThenElse(ISymbolicExpressionTreeNode condition,
+    private static ISymbolicExpressionTreeNode MakeIfThenElse(ISymbolicExpressionTreeNode condition,
       ISymbolicExpressionTreeNode trueBranch, ISymbolicExpressionTreeNode falseBranch) {
       if (IsConstant(condition)) {
@@ -620,5 +623,5 @@
     }
 
-    private ISymbolicExpressionTreeNode MakeSine(ISymbolicExpressionTreeNode node) {
+    private static ISymbolicExpressionTreeNode MakeSine(ISymbolicExpressionTreeNode node) {
       if (IsConstant(node)) {
         var constT = node as ConstantTreeNode;
@@ -637,5 +640,5 @@
     }
 
-    private ISymbolicExpressionTreeNode MakeTangent(ISymbolicExpressionTreeNode node) {
+    private static ISymbolicExpressionTreeNode MakeTangent(ISymbolicExpressionTreeNode node) {
       if (IsConstant(node)) {
         var constT = node as ConstantTreeNode;
@@ -654,5 +657,5 @@
     }
 
-    private ISymbolicExpressionTreeNode MakeCosine(ISymbolicExpressionTreeNode node) {
+    private static ISymbolicExpressionTreeNode MakeCosine(ISymbolicExpressionTreeNode node) {
       if (IsConstant(node)) {
         var constT = node as ConstantTreeNode;
@@ -673,5 +676,5 @@
     }
 
-    private ISymbolicExpressionTreeNode MakeExp(ISymbolicExpressionTreeNode node) {
+    private static ISymbolicExpressionTreeNode MakeExp(ISymbolicExpressionTreeNode node) {
       if (IsConstant(node)) {
         var constT = node as ConstantTreeNode;
@@ -697,5 +700,5 @@
       }
     }
-    private ISymbolicExpressionTreeNode MakeLog(ISymbolicExpressionTreeNode node) {
+    private static ISymbolicExpressionTreeNode MakeLog(ISymbolicExpressionTreeNode node) {
       if (IsConstant(node)) {
         var constT = node as ConstantTreeNode;
@@ -715,5 +718,5 @@
     }
 
-    private ISymbolicExpressionTreeNode MakeSquare(ISymbolicExpressionTreeNode node) {
+    private static ISymbolicExpressionTreeNode MakeSquare(ISymbolicExpressionTreeNode node) {
       if (IsConstant(node)) {
         var constT = node as ConstantTreeNode;
@@ -734,5 +737,5 @@
     }
 
-    private ISymbolicExpressionTreeNode MakeSquareRoot(ISymbolicExpressionTreeNode node) {
+    private static ISymbolicExpressionTreeNode MakeSquareRoot(ISymbolicExpressionTreeNode node) {
       if (IsConstant(node)) {
         var constT = node as ConstantTreeNode;
@@ -753,5 +756,5 @@
     }
 
-    private ISymbolicExpressionTreeNode MakeRoot(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
+    private static ISymbolicExpressionTreeNode MakeRoot(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
       if (IsConstant(a) && IsConstant(b)) {
         var constA = a as ConstantTreeNode;
@@ -808,5 +811,5 @@
 
 
-    private ISymbolicExpressionTreeNode MakePower(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
+    private static ISymbolicExpressionTreeNode MakePower(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
       if (IsConstant(a) && IsConstant(b)) {
         var constA = a as ConstantTreeNode;
@@ -863,5 +866,5 @@
 
     // MakeFraction, MakeProduct and MakeSum take two already simplified trees and create a new simplified tree
-    private ISymbolicExpressionTreeNode MakeFraction(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
+    private static ISymbolicExpressionTreeNode MakeFraction(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
       if (IsConstant(a) && IsConstant(b)) {
         // fold constants
@@ -932,5 +935,5 @@
     }
 
-    private ISymbolicExpressionTreeNode MakeSum(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
+    private static ISymbolicExpressionTreeNode MakeSum(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
       if (IsConstant(a) && IsConstant(b)) {
         // fold constants
@@ -1027,5 +1030,5 @@
 
     // makes sure variable symbols in sums are combined
-    private void MergeVariablesInSum(ISymbolicExpressionTreeNode sum) {
+    private static void MergeVariablesInSum(ISymbolicExpressionTreeNode sum) {
       var subtrees = new List<ISymbolicExpressionTreeNode>(sum.Subtrees);
       while (sum.Subtrees.Any()) sum.RemoveSubtree(0);
@@ -1066,5 +1069,5 @@
 
     // nodes referencing variables can be grouped if they have
-    private string GroupId(IVariableTreeNode node) {
+    private static string GroupId(IVariableTreeNode node) {
       var binaryFactorNode = node as BinaryFactorVariableTreeNode;
       var factorNode = node as FactorVariableTreeNode;
@@ -1085,5 +1088,5 @@
 
 
-    private ISymbolicExpressionTreeNode MakeProduct(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
+    private static ISymbolicExpressionTreeNode MakeProduct(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
       if (IsConstant(a) && IsConstant(b)) {
         // fold constants
@@ -1166,5 +1169,5 @@
     #region helper functions
 
-    private bool ContainsVariableCondition(ISymbolicExpressionTreeNode node) {
+    private static bool ContainsVariableCondition(ISymbolicExpressionTreeNode node) {
       if (node.Symbol is VariableCondition) return true;
       foreach (var subtree in node.Subtrees)
@@ -1173,5 +1176,5 @@
     }
 
-    private ISymbolicExpressionTreeNode AddLagToDynamicNodes(ISymbolicExpressionTreeNode node, int lag) {
+    private static ISymbolicExpressionTreeNode AddLagToDynamicNodes(ISymbolicExpressionTreeNode node, int lag) {
       var laggedTreeNode = node as ILaggedTreeNode;
       var variableNode = node as VariableTreeNode;
@@ -1195,10 +1198,10 @@
     }
 
-    private bool AreSameTypeAndVariable(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
+    private static bool AreSameTypeAndVariable(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
       return GroupId((IVariableTreeNode)a) == GroupId((IVariableTreeNode)b);
     }
 
     // helper to combine the constant factors in products and to combine variables (powers of 2, 3...)
-    private void MergeVariablesAndConstantsInProduct(ISymbolicExpressionTreeNode prod) {
+    private static void MergeVariablesAndConstantsInProduct(ISymbolicExpressionTreeNode prod) {
       var subtrees = new List<ISymbolicExpressionTreeNode>(prod.Subtrees);
       while (prod.Subtrees.Any()) prod.RemoveSubtree(0);
@@ -1264,5 +1267,5 @@
     /// <param name="x"></param>
     /// <returns>-x</returns>
-    private ISymbolicExpressionTreeNode Negate(ISymbolicExpressionTreeNode x) {
+    private static ISymbolicExpressionTreeNode Negate(ISymbolicExpressionTreeNode x) {
       if (IsConstant(x)) {
         ((ConstantTreeNode)x).Value *= -1;
@@ -1301,5 +1304,5 @@
     /// <param name="x"></param>
     /// <returns></returns>
-    private ISymbolicExpressionTreeNode Invert(ISymbolicExpressionTreeNode x) {
+    private static ISymbolicExpressionTreeNode Invert(ISymbolicExpressionTreeNode x) {
       if (IsConstant(x)) {
         return MakeConstant(1.0 / ((ConstantTreeNode)x).Value);
@@ -1315,5 +1318,5 @@
     }
 
-    private ISymbolicExpressionTreeNode MakeConstant(double value) {
+    private static ISymbolicExpressionTreeNode MakeConstant(double value) {
       ConstantTreeNode constantTreeNode = (ConstantTreeNode)(constSymbol.CreateTreeNode());
       constantTreeNode.Value = value;
@@ -1321,5 +1324,5 @@
     }
 
-    private ISymbolicExpressionTreeNode MakeFactor(FactorVariable sy, string variableName, IEnumerable<double> weights) {
+    private static ISymbolicExpressionTreeNode MakeFactor(FactorVariable sy, string variableName, IEnumerable<double> weights) {
       var tree = (FactorVariableTreeNode)sy.CreateTreeNode();
       tree.VariableName = variableName;
@@ -1327,5 +1330,5 @@
       return tree;
     }
-    private ISymbolicExpressionTreeNode MakeBinFactor(BinaryFactorVariable sy, string variableName, string variableValue, double weight) {
+    private static ISymbolicExpressionTreeNode MakeBinFactor(BinaryFactorVariable sy, string variableName, string variableValue, double weight) {
       var tree = (BinaryFactorVariableTreeNode)sy.CreateTreeNode();
       tree.VariableName = variableName;
Index: trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeSimplificationOperator.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeSimplificationOperator.cs	(revision 14948)
+++ trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeSimplificationOperator.cs	(revision 14949)
@@ -37,6 +37,4 @@
     }
 
-    private readonly TreeSimplifier simplifier = new TreeSimplifier();
-
     [StorableConstructor]
     protected SymbolicDataAnalysisExpressionTreeSimplificationOperator(bool deserializing) : base(deserializing) { }
@@ -53,6 +51,6 @@
     public override IOperation Apply() {
       var tree = SymbolicExpressionTreeParameter.ActualValue;
-      var simplifiedTree = simplifier.Simplify(tree);
-      simplifiedTree = simplifier.Simplify(simplifiedTree);
+      var simplifiedTree = TreeSimplifier.Simplify(tree);
+      simplifiedTree = TreeSimplifier.Simplify(simplifiedTree);
       SymbolicExpressionTreeParameter.ActualValue = simplifiedTree;
 
