Index: branches/DataPreprocessing/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicExpressionTreeBacktransformator.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicExpressionTreeBacktransformator.cs	(revision 10871)
+++ branches/DataPreprocessing/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicExpressionTreeBacktransformator.cs	(revision 10872)
@@ -27,7 +27,7 @@
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
   public class SymbolicExpressionTreeBacktransformator : IModelBacktransformator {
-    private readonly ITransformationMapper<ISymbolicExpressionTree> transformationMapper;
+    private readonly ITransformationMapper<ISymbolicExpressionTreeNode> transformationMapper;
 
-    public SymbolicExpressionTreeBacktransformator(ITransformationMapper<ISymbolicExpressionTree> transformationMapper) {
+    public SymbolicExpressionTreeBacktransformator(ITransformationMapper<ISymbolicExpressionTreeNode> transformationMapper) {
       this.transformationMapper = transformationMapper;
     }
@@ -51,9 +51,9 @@
     }
 
-    private void SwapTransformationTree(ISymbolicExpressionTree transformationTree, ISymbolicExpressionTreeNode targetNode) {
+    private void SwapTransformationTree(ISymbolicExpressionTreeNode transformationTreeNode, ISymbolicExpressionTreeNode targetNode) {
       var parent = targetNode.Parent;
       int index = parent.IndexOfSubtree(targetNode);
       parent.RemoveSubtree(index);
-      parent.InsertSubtree(index, transformationTree.Root.GetSubtree(0));
+      parent.InsertSubtree(index, transformationTreeNode);
     }
 
Index: branches/DataPreprocessing/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TransformationToSymbolicTreeMapper.cs
===================================================================
--- branches/DataPreprocessing/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TransformationToSymbolicTreeMapper.cs	(revision 10871)
+++ branches/DataPreprocessing/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TransformationToSymbolicTreeMapper.cs	(revision 10872)
@@ -25,12 +25,11 @@
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
-  public class TransformationToSymbolicTreeMapper : ITransformationMapper<ISymbolicExpressionTree> {
+  public class TransformationToSymbolicTreeMapper : ITransformationMapper<ISymbolicExpressionTreeNode> {
     private ITransformation transformation;
     private string column;
-    private ISymbolicExpressionTree tree;
 
     #region ITransformationMapper<ISymbolicExpressionTree> Members
 
-    public ISymbolicExpressionTree GenerateModel(ITransformation transformation) {
+    public ISymbolicExpressionTreeNode GenerateModel(ITransformation transformation) {
       InitComponents(transformation);
 
@@ -51,5 +50,5 @@
     }
 
-    public ISymbolicExpressionTree GenerateInverseModel(ITransformation transformation) {
+    public ISymbolicExpressionTreeNode GenerateInverseModel(ITransformation transformation) {
       InitComponents(transformation);
 
@@ -75,5 +74,5 @@
     // helper
 
-    private ISymbolicExpressionTree GenerateModelForLinearTransformation() {
+    private ISymbolicExpressionTreeNode GenerateModelForLinearTransformation() {
       var linearTransformation = (LinearTransformation)transformation;
       var kValue = linearTransformation.Multiplier;
@@ -93,9 +92,8 @@
       additionNode.AddSubtree(dNode);
 
-      tree.Root.AddSubtree(additionNode);
-      return tree;
-    }
-
-    private ISymbolicExpressionTree GenerateInverseModelForLinearTransformation() {
+      return additionNode;
+    }
+
+    private ISymbolicExpressionTreeNode GenerateInverseModelForLinearTransformation() {
       var linearTransformation = (LinearTransformation)transformation;
       var kValue = linearTransformation.Multiplier;
@@ -115,10 +113,9 @@
       divisionNode.AddSubtree(kNode);
 
-      tree.Root.AddSubtree(divisionNode);
-      return tree;
-    }
-
-
-    private ISymbolicExpressionTree GenerateModelForExponentialTransformation() {
+      return divisionNode;
+    }
+
+
+    private ISymbolicExpressionTreeNode GenerateModelForExponentialTransformation() {
       var exponentialTransformation = (ExponentialTransformation)transformation;
       var bValue = exponentialTransformation.Base;
@@ -127,5 +124,5 @@
     }
 
-    private ISymbolicExpressionTree GenerateInverseModelForExponentialTransformation() {
+    private ISymbolicExpressionTreeNode GenerateInverseModelForExponentialTransformation() {
       var exponentialTransformation = (ExponentialTransformation)transformation;
       var bValue = exponentialTransformation.Base;
@@ -135,5 +132,5 @@
 
 
-    private ISymbolicExpressionTree GenerateModelForLogarithmicTransformation() {
+    private ISymbolicExpressionTreeNode GenerateModelForLogarithmicTransformation() {
       var logarithmicTransformation = (LogarithmicTransformation)transformation;
       var bValue = logarithmicTransformation.Base;
@@ -142,5 +139,5 @@
     }
 
-    private ISymbolicExpressionTree GenerateInverseModelForLogarithmicTransformation() {
+    private ISymbolicExpressionTreeNode GenerateInverseModelForLogarithmicTransformation() {
       var logarithmicTransformation = (LogarithmicTransformation)transformation;
       var bValue = logarithmicTransformation.Base;
@@ -150,5 +147,5 @@
 
 
-    private ISymbolicExpressionTree GenerateModelForPowerTransformation() {
+    private ISymbolicExpressionTreeNode GenerateModelForPowerTransformation() {
       var powerTransformation = (PowerTransformation)transformation;
       var expValue = powerTransformation.Exponent;
@@ -161,9 +158,8 @@
       powerNode.AddSubtree(expNode);
 
-      tree.Root.AddSubtree(powerNode);
-      return tree;
-    }
-
-    private ISymbolicExpressionTree GenerateInverseModelForPowerTransformation() {
+      return powerNode;
+    }
+
+    private ISymbolicExpressionTreeNode GenerateInverseModelForPowerTransformation() {
       var powerTransformation = (PowerTransformation)transformation;
       var expValue = powerTransformation.Exponent;
@@ -176,18 +172,18 @@
       rootNode.AddSubtree(bNode);
 
-      tree.Root.AddSubtree(rootNode);
-      return tree;
-    }
-
-
-    private ISymbolicExpressionTree GenerateModelForReciprocalTransformation() {
+      return rootNode;
+    }
+
+
+    private ISymbolicExpressionTreeNode GenerateModelForReciprocalTransformation() {
       return GenTreeDiv_1_x();
     }
 
-    private ISymbolicExpressionTree GenerateInverseModelForReciprocalTransformation() {
+    private ISymbolicExpressionTreeNode GenerateInverseModelForReciprocalTransformation() {
       return GenTreeDiv_1_x();
     }
 
-    private ISymbolicExpressionTree GenerateModelForShiftStandardDistributionTransformation() {
+
+    private ISymbolicExpressionTreeNode GenerateModelForShiftStandardDistributionTransformation() {
       var shiftStandardDistributionTransformation = (ShiftStandardDistributionTransformation)transformation;
       var m_orgValue = shiftStandardDistributionTransformation.OriginalMean;
@@ -199,5 +195,5 @@
     }
 
-    private ISymbolicExpressionTree GenerateInverseModelForShiftStandardDistributionTransformation() {
+    private ISymbolicExpressionTreeNode GenerateInverseModelForShiftStandardDistributionTransformation() {
       var shiftStandardDistributionTransformation = (ShiftStandardDistributionTransformation)transformation;
       var m_orgValue = shiftStandardDistributionTransformation.OriginalMean;
@@ -211,7 +207,5 @@
     // helper's helper:
 
-    private ISymbolicExpressionTree GenTreeLog_x_b(double b) {
-      var tree = CreateNewTree();
-
+    private ISymbolicExpressionTreeNode GenTreeLog_x_b(double b) {
       // log(x, b)
       var logNode = new Logarithm().CreateTreeNode();
@@ -221,11 +215,8 @@
       logNode.AddSubtree(bNode);
 
-      tree.Root.AddSubtree(logNode);
-      return tree;
-    }
-
-    private ISymbolicExpressionTree GenTreePow_b_x(double b) {
-      var tree = CreateNewTree();
-
+      return logNode;
+    }
+
+    private ISymbolicExpressionTreeNode GenTreePow_b_x(double b) {
       // b ^ x
       var powerNode = new Power().CreateTreeNode();
@@ -235,11 +226,8 @@
       powerNode.AddSubtree(xNode);
 
-      tree.Root.AddSubtree(powerNode);
-      return tree;
-    }
-
-    private ISymbolicExpressionTree GenTreeDiv_1_x() {
-      var tree = CreateNewTree();
-
+      return powerNode;
+    }
+
+    private ISymbolicExpressionTreeNode GenTreeDiv_1_x() {
       // 1 / x
       var divNode = new Division().CreateTreeNode();
@@ -249,9 +237,8 @@
       divNode.AddSubtree(xNode);
 
-      tree.Root.AddSubtree(divNode);
-      return tree;
-    }
-    private ISymbolicExpressionTree GenTreeShiftStdDist(string variable, double m_org, double s_org, double m_tar, double s_tar) {
-      var tree = CreateNewTree();
+      return divNode;
+    }
+
+    private ISymbolicExpressionTreeNode GenTreeShiftStdDist(string variable, double m_org, double s_org, double m_tar, double s_tar) {
       // x - m_org
       var substractionNode = new Subtraction().CreateTreeNode();
@@ -279,6 +266,5 @@
       additionNode.AddSubtree(m_tarNode);
 
-      tree.Root.AddSubtree(additionNode);
-      return tree;
+      return additionNode;
     }
 
@@ -286,11 +272,7 @@
       return new ConstantTreeNode(new Constant()) { Value = value };
     }
+
     private ISymbolicExpressionTreeNode CreateVariableTreeNode(string name, string description) {
       return new Variable(name, description).CreateTreeNode();
-    }
-
-
-    private ISymbolicExpressionTree CreateNewTree() {
-      return new SymbolicExpressionTree(new ProgramRootSymbol().CreateTreeNode());
     }
 
@@ -298,5 +280,4 @@
       this.transformation = transformation;
       column = transformation.Column;
-      tree = CreateNewTree();
     }
   }
