Index: /branches/2906_Transformations/HeuristicLab.DataPreprocessing.Views/3.4/PreprocessingCheckedVariablesView.cs
===================================================================
--- /branches/2906_Transformations/HeuristicLab.DataPreprocessing.Views/3.4/PreprocessingCheckedVariablesView.cs	(revision 15883)
+++ /branches/2906_Transformations/HeuristicLab.DataPreprocessing.Views/3.4/PreprocessingCheckedVariablesView.cs	(revision 15884)
@@ -42,4 +42,10 @@
     protected PreprocessingCheckedVariablesView() {
       InitializeComponent();
+
+      // TODO: fix auto-size of columns
+      //for (int i = 0; i < variablesListView.Columns.Count; i++) {
+      //  variablesListView.Columns[i].Width = -1;
+      //  variablesListView.Columns[i].AutoResize(ColumnHeaderAutoResizeStyle.ColumnContent);
+      //}
     }
 
Index: /branches/2906_Transformations/HeuristicLab.DataPreprocessing/3.4/ProblemDataCreator.cs
===================================================================
--- /branches/2906_Transformations/HeuristicLab.DataPreprocessing/3.4/ProblemDataCreator.cs	(revision 15883)
+++ /branches/2906_Transformations/HeuristicLab.DataPreprocessing/3.4/ProblemDataCreator.cs	(revision 15884)
@@ -23,5 +23,4 @@
 using System.Collections.Generic;
 using System.Linq;
-using HeuristicLab.Common;
 using HeuristicLab.Problems.DataAnalysis;
 
@@ -46,5 +45,4 @@
 
       IDataAnalysisProblemData problemData;
-
       if (oldProblemData is TimeSeriesPrognosisProblemData) {
         problemData = CreateTimeSeriesPrognosisData((TimeSeriesPrognosisProblemData)oldProblemData);
@@ -59,12 +57,6 @@
       }
 
-      SetTrainingAndTestPartition(problemData);
-      SetAllowedInputVariables(problemData, oldProblemData.AllowedInputVariables);
-      // set the input variables to the correct checked state
-      //var inputVariables = oldProblemData.InputVariables.ToDictionary(x => x.Value, x => x);
-      //foreach (var variable in problemData.InputVariables) {
-      //  bool isChecked = inputVariables.ContainsKey(variable.Value) && oldProblemData.InputVariables.ItemChecked(inputVariables[variable.Value]);
-      //  problemData.InputVariables.SetItemCheckedState(variable, isChecked);
-      //}
+      SetTrainingAndTestPartition(problemData, context.Data);
+      SetAllowedInputVariables(problemData, oldProblemData);
 
       return problemData;
@@ -75,6 +67,5 @@
       if (!context.Data.VariableNames.Contains(targetVariable))
         targetVariable = context.Data.VariableNames.First();
-      var inputVariables = GetDoubleInputVariables(targetVariable);
-      var newProblemData = new TimeSeriesPrognosisProblemData(ExportedDataset, inputVariables, targetVariable, CreateDataAnalysisTransformation()) {
+      var newProblemData = new TimeSeriesPrognosisProblemData(ExportedDataset, Enumerable.Empty<string>(), targetVariable, CreateDataAnalysisTransformation()) {
         TrainingHorizon = oldProblemData.TrainingHorizon,
         TestHorizon = oldProblemData.TestHorizon
@@ -84,10 +75,8 @@
 
     private IDataAnalysisProblemData CreateRegressionData(RegressionProblemData oldProblemData) {
-      // TODO: transformations (additional inputs, target changed)
-      var targetVariable = RegressionTransformationModel.GetTransformedTragetVariable(oldProblemData.TargetVariable, CreateDataAnalysisTransformation());
+      var targetVariable = DataAnalysisTransformation.GetLastTransitiveVariable(oldProblemData.TargetVariable, CreateDataAnalysisTransformation());
       if (!context.Data.VariableNames.Contains(targetVariable))
         targetVariable = context.Data.VariableNames.First();
-      var inputVariables = GetDoubleInputVariables(targetVariable);
-      var newProblemData = new RegressionProblemData(ExportedDataset, inputVariables, targetVariable, CreateDataAnalysisTransformation());
+      var newProblemData = new RegressionProblemData(ExportedDataset, Enumerable.Empty<string>(), targetVariable, CreateDataAnalysisTransformation());
       return newProblemData;
     }
@@ -97,6 +86,5 @@
       if (!context.Data.VariableNames.Contains(targetVariable))
         targetVariable = context.Data.VariableNames.First();
-      var inputVariables = GetDoubleInputVariables(targetVariable);
-      var newProblemData = new ClassificationProblemData(ExportedDataset, inputVariables, targetVariable, CreateDataAnalysisTransformation()) {
+      var newProblemData = new ClassificationProblemData(ExportedDataset, Enumerable.Empty<string>(), targetVariable, CreateDataAnalysisTransformation()) {
         PositiveClass = oldProblemData.PositiveClass
       };
@@ -105,10 +93,8 @@
 
     private IDataAnalysisProblemData CreateClusteringData(ClusteringProblemData oldProblemData) {
-      return new ClusteringProblemData(ExportedDataset, GetDoubleInputVariables(String.Empty), CreateDataAnalysisTransformation());
+      return new ClusteringProblemData(ExportedDataset, Enumerable.Empty<string>(), CreateDataAnalysisTransformation());
     }
 
-    private void SetTrainingAndTestPartition(IDataAnalysisProblemData problemData) {
-      var ppData = context.Data;
-
+    private static void SetTrainingAndTestPartition(IDataAnalysisProblemData problemData, IPreprocessingData ppData) {
       problemData.TrainingPartition.Start = ppData.TrainingPartition.Start;
       problemData.TrainingPartition.End = ppData.TrainingPartition.End;
@@ -117,28 +103,18 @@
     }
 
-    void SetAllowedInputVariables(IDataAnalysisProblemData problemData, IEnumerable<string> oldInputVariables) {
-      var inputs = DataAnalysisTransformationModel.ExtendInputVariables(oldInputVariables, problemData.Transformations);
-
+    private static void SetAllowedInputVariables(IDataAnalysisProblemData problemData, IDataAnalysisProblemData oldProblemData) {
+      // original inputs + extended(transitive) inputs
+      var inputs = DataAnalysisTransformation.ExtendVariables(oldProblemData.AllowedInputVariables, problemData.Transformations).ToList();
       foreach (var input in problemData.InputVariables) {
         problemData.InputVariables.SetItemCheckedState(input, inputs.Contains(input.Value));
       }
-    }
 
-    private IEnumerable<string> GetDoubleInputVariables(string targetVariable) {
-      var variableNames = new List<string>();
-      for (int i = 0; i < context.Data.Columns; ++i) {
-        var variableName = context.Data.GetVariableName(i);
-        if (context.Data.VariableHasType<double>(i)
-          && variableName != targetVariable
-          && IsNotConstantInputVariable(context.Data.GetValues<double>(i))) {
-
-          variableNames.Add(variableName);
-        }
+      // new variables that were not created via transformations
+      var originalAndVirtualVariables = DataAnalysisTransformation.ExtendVariables(oldProblemData.Dataset.VariableNames, problemData.Transformations);
+      var newVariables = problemData.Dataset.VariableNames.Except(originalAndVirtualVariables).ToList();
+      foreach (var input in problemData.InputVariables) {
+        if (newVariables.Contains(input.Value))
+          problemData.InputVariables.SetItemCheckedState(input, true);
       }
-      return variableNames;
-    }
-
-    private bool IsNotConstantInputVariable(IList<double> list) {
-      return context.Data.TrainingPartition.End - context.Data.TrainingPartition.Start > 1 || list.Range() > 0;
     }
 
Index: /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis.Views/3.4/DataAnalysisTransformationModelView.Designer.cs
===================================================================
--- /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis.Views/3.4/DataAnalysisTransformationModelView.Designer.cs	(revision 15883)
+++ /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis.Views/3.4/DataAnalysisTransformationModelView.Designer.cs	(revision 15884)
@@ -45,5 +45,5 @@
     /// </summary>
     private void InitializeComponent() {
-      this.originalModelTabPage = new System.Windows.Forms.TabPage();
+      this.trainedModelTabPage = new System.Windows.Forms.TabPage();
       this.modelViewHost = new HeuristicLab.MainForm.WindowsForms.ViewHost();
       this.tabControl = new System.Windows.Forms.TabControl();
@@ -52,5 +52,5 @@
       this.targetTransformationsTabPage = new System.Windows.Forms.TabPage();
       this.targetTransformationsViewHost = new HeuristicLab.MainForm.WindowsForms.ViewHost();
-      this.originalModelTabPage.SuspendLayout();
+      this.trainedModelTabPage.SuspendLayout();
       this.tabControl.SuspendLayout();
       this.inputTransformationsTabPage.SuspendLayout();
@@ -58,14 +58,14 @@
       this.SuspendLayout();
       // 
-      // originalModelTabPage
+      // trainedModelTabPage
       // 
-      this.originalModelTabPage.Controls.Add(this.modelViewHost);
-      this.originalModelTabPage.Location = new System.Drawing.Point(4, 22);
-      this.originalModelTabPage.Name = "originalModelTabPage";
-      this.originalModelTabPage.Padding = new System.Windows.Forms.Padding(3);
-      this.originalModelTabPage.Size = new System.Drawing.Size(486, 392);
-      this.originalModelTabPage.TabIndex = 0;
-      this.originalModelTabPage.Text = "Original Model";
-      this.originalModelTabPage.UseVisualStyleBackColor = true;
+      this.trainedModelTabPage.Controls.Add(this.modelViewHost);
+      this.trainedModelTabPage.Location = new System.Drawing.Point(4, 22);
+      this.trainedModelTabPage.Name = "trainedModelTabPage";
+      this.trainedModelTabPage.Padding = new System.Windows.Forms.Padding(3);
+      this.trainedModelTabPage.Size = new System.Drawing.Size(486, 392);
+      this.trainedModelTabPage.TabIndex = 0;
+      this.trainedModelTabPage.Text = "Trained Model";
+      this.trainedModelTabPage.UseVisualStyleBackColor = true;
       // 
       // modelViewHost
@@ -88,5 +88,5 @@
             | System.Windows.Forms.AnchorStyles.Left) 
             | System.Windows.Forms.AnchorStyles.Right)));
-      this.tabControl.Controls.Add(this.originalModelTabPage);
+      this.tabControl.Controls.Add(this.trainedModelTabPage);
       this.tabControl.Controls.Add(this.inputTransformationsTabPage);
       this.tabControl.Controls.Add(this.targetTransformationsTabPage);
@@ -154,5 +154,5 @@
       this.Name = "DataAnalysisTransformationModelView";
       this.Size = new System.Drawing.Size(500, 424);
-      this.originalModelTabPage.ResumeLayout(false);
+      this.trainedModelTabPage.ResumeLayout(false);
       this.tabControl.ResumeLayout(false);
       this.inputTransformationsTabPage.ResumeLayout(false);
@@ -164,5 +164,5 @@
     #endregion
 
-    private System.Windows.Forms.TabPage originalModelTabPage;
+    private System.Windows.Forms.TabPage trainedModelTabPage;
     private MainForm.WindowsForms.ViewHost modelViewHost;
     private System.Windows.Forms.TabControl tabControl;
Index: /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis.Views/3.4/DataAnalysisTransformationModelView.cs
===================================================================
--- /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis.Views/3.4/DataAnalysisTransformationModelView.cs	(revision 15883)
+++ /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis.Views/3.4/DataAnalysisTransformationModelView.cs	(revision 15884)
@@ -18,5 +18,5 @@
  * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
  */
-#endregion            
+#endregion
 
 using HeuristicLab.Core.Views;
@@ -25,9 +25,9 @@
 namespace HeuristicLab.Problems.DataAnalysis.Views {
   [View("Transformation Model View")]
-  [Content(typeof(IDataAnalysisTransformationModel), true)]
+  [Content(typeof(DataAnalysisTransformationModel), true)]
   public partial class DataAnalysisTransformationModelView : ItemView {
 
-    public new IDataAnalysisTransformationModel Content {
-      get { return (IDataAnalysisTransformationModel)base.Content; }
+    public new DataAnalysisTransformationModel Content {
+      get { return (DataAnalysisTransformationModel)base.Content; }
       set { base.Content = value; }
     }
Index: /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis.Views/3.4/Solution Views/DataAnalysisSolutionView.cs
===================================================================
--- /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis.Views/3.4/Solution Views/DataAnalysisSolutionView.cs	(revision 15883)
+++ /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis.Views/3.4/Solution Views/DataAnalysisSolutionView.cs	(revision 15884)
@@ -40,5 +40,5 @@
 
     private const string BacktransformButtonText = "Integrate Transformations";
-    private const string ReapplyTransformationsButtonText = "Restore Original Model";
+    private const string ReapplyTransformationsButtonText = "Restore Trained Model";
 
     public DataAnalysisSolutionView() {
@@ -93,5 +93,6 @@
 
       transformButton.Text = Content.Model is IDataAnalysisTransformationModel
-        ? ReapplyTransformationsButtonText : BacktransformButtonText;
+        ? ReapplyTransformationsButtonText
+        : BacktransformButtonText;
     }
 
@@ -237,4 +238,5 @@
         problemData = param.Value as DataAnalysisProblemData;
       }
+
       if (problemData == null) return;
 
@@ -258,41 +260,7 @@
 
     private void transformButton_Click(object sender, EventArgs e) {
-      var transformedSolution = CreateTransformedSolution(Content);
+      var transformedSolution = DataAnalysisTransformation.TransformSolution(Content);
       MainFormManager.MainForm.ShowContent(transformedSolution);
     }
-
-    private static IDataAnalysisSolution CreateTransformedSolution(IDataAnalysisSolution solution) {
-      if (solution.Model is IRegressionTransformationModel regressionTransformationModel && !(solution.Model is ITimeSeriesPrognosisTransformationModel)) {
-        var originalData = (IRegressionProblemData)((IRegressionSolution)solution).ProblemData.Transform();
-        return regressionTransformationModel.OriginalModel.CreateRegressionSolution(originalData);
-      } else if (solution.Model is IClassificationTransformationModel classificationTransformationModel) {
-        var originalData = (IClassificationProblemData)((IClassificationSolution)solution).ProblemData.Transform();
-        return classificationTransformationModel.OriginalModel.CreateClassificationSolution(originalData);
-      } else if (solution.Model is IRegressionModel regressionModel && !(solution.Model is ITimeSeriesPrognosisModel)) {
-        var transformationModel = new RegressionTransformationModel(regressionModel, solution.ProblemData.Transformations);
-        var transformedData = (IRegressionProblemData)((IRegressionSolution)solution).ProblemData.InverseTransform();
-        return transformationModel.CreateRegressionSolution(transformedData);
-      } else if (solution.Model is IClassificationModel classificationModel) {
-        var transformationModel = new ClassificationTransformationModel(classificationModel, solution.ProblemData.Transformations);
-        var transformedData = (IClassificationProblemData)((IClassificationSolution)solution).ProblemData.InverseTransform();
-        return transformationModel.CreateClassificationSolution(transformedData);
-      } else throw new NotSupportedException();
-    }
-
-    /*if (Content.Model is IDataAnalysisTransformationModel transformationModel) {
-      var originalModel = transformationModel.InverseTransform();
-      originalModel.CreateSolution();
-    } else {
-      var originalModel = Content.Model;
-      var transformationModel = originalModel.Transform();
-      transformationModel.CreateSolution();
-    }*/
-
-    ////Content.Model.Transform()
-
-    //var transformedModel = new DataAnalysisTransformationModel(Content.Model, Content.ProblemData.Transformations);
-    //var originalProblemData = (IRegressionProblemData)Content.ProblemData.InverseTransform();
-    //var transformedSolution = new TransformedRegressionSolution(transformedModel, originalProblemData);
-    //MainFormManager.MainForm.ShowContent(transformedSolution);
   }
 }
Index: /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationTransformationModel.cs
===================================================================
--- /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationTransformationModel.cs	(revision 15883)
+++ /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationTransformationModel.cs	(revision 15884)
@@ -35,9 +35,8 @@
     }
 
-
     #region Constructor, Cloning & Persistence
     public ClassificationTransformationModel(IClassificationModel originalModel, IEnumerable<IDataAnalysisTransformation> transformations)
       : base(originalModel, transformations) {
-      if (CalculateTransitiveVariables(new[] { originalModel.TargetVariable }, transformations).Any())
+      if (DataAnalysisTransformation.GetTransitiveVariables(new[] { originalModel.TargetVariable }, transformations).Any())
         throw new NotSupportedException("Classification with a transformed target variable is not allowed");
     }
@@ -57,5 +56,6 @@
 
     public virtual IEnumerable<double> GetEstimatedClassValues(IDataset dataset, IEnumerable<int> rows) {
-      return OriginalModel.GetEstimatedClassValues(Transform(dataset, InputTransformations), rows);
+      var transformedInput = DataAnalysisTransformation.Transform(dataset, InputTransformations);
+      return OriginalModel.GetEstimatedClassValues(transformedInput, rows);
     }
 
Index: /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Clustering/ClusteringTransformationModel.cs
===================================================================
--- /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Clustering/ClusteringTransformationModel.cs	(revision 15883)
+++ /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Clustering/ClusteringTransformationModel.cs	(revision 15884)
@@ -53,5 +53,6 @@
 
     public IEnumerable<int> GetClusterValues(IDataset dataset, IEnumerable<int> rows) {
-      return OriginalModel.GetClusterValues(Transform(dataset, InputTransformations), rows);
+      var transformedInputs = DataAnalysisTransformation.Transform(dataset, InputTransformations);
+      return OriginalModel.GetClusterValues(transformedInputs, rows);
     }
   }
Index: /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/DataAnalysisProblemData.cs
===================================================================
--- /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/DataAnalysisProblemData.cs	(revision 15883)
+++ /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/DataAnalysisProblemData.cs	(revision 15884)
@@ -241,60 +241,4 @@
       }
     }
-
-    public virtual IDataAnalysisProblemData Transform() {
-      var newDataset = DataAnalysisTransformationModel.Transform(Dataset, Transformations);
-
-      var extendedInputs = DataAnalysisTransformationModel.ExtendInputVariables(AllowedInputVariables, Transformations);
-      var checkedInputs = new CheckedItemList<StringValue>(newDataset.VariableNames.Select(x => new StringValue(x)));
-      foreach (var input in checkedInputs) checkedInputs.SetItemCheckedState(input, extendedInputs.Contains(input.Value));
-
-      // TODO: Cannot create concrete instance here (maybe derived Create-method?)
-      var cloner = new Cloner();
-      cloner.RegisterClonedObject(Dataset, newDataset);
-      cloner.RegisterClonedObject(InputVariables, checkedInputs.AsReadOnly());
-      // TODO: valid values for target are not extended
-
-      return cloner.Clone(this);
-    }
-
-    public virtual IDataAnalysisProblemData InverseTransform() {
-      var newDataset = InverseTransform(Dataset, Transformations);
-
-      var checkedInputs = new CheckedItemList<StringValue>(newDataset.VariableNames.Select(x => new StringValue(x)));
-      foreach (var input in checkedInputs) checkedInputs.SetItemCheckedState(input, AllowedInputVariables.Contains(input.Value));
-
-      // TODO: Cannot create concrete instance here (maybe derived Create-method?)
-      var cloner = new Cloner();
-      cloner.RegisterClonedObject(Dataset, newDataset);
-      cloner.RegisterClonedObject(InputVariables, checkedInputs.AsReadOnly());
-      // TODO: check valid target values 
-
-      return cloner.Clone(this);
-    }
-
-    public static IDataset InverseTransform(IDataset dataset, IEnumerable<IDataAnalysisTransformation> transformations, bool removeVirtualVariables = true) {
-      var modifiableDataset = ((Dataset)dataset).ToModifiable();
-
-      var transformationsStack = new Stack<IDataAnalysisTransformation>(transformations);
-      while (transformationsStack.Any()) {
-        var transformation = transformationsStack.Pop();
-        var trans = (ITransformation<double>)transformation.Transformation;
-
-        var prevTransformations = transformations.Except(transformationsStack);
-        bool originalWasChanged = prevTransformations.Any(x => x.TransformedVariable == transformation.OriginalVariable);
-        if (originalWasChanged) {
-          var transformedData = modifiableDataset.GetDoubleValues(transformation.TransformedVariable);
-
-          var originalData = trans.InverseApply(transformedData).ToList();
-          modifiableDataset.ReplaceVariable(transformation.OriginalVariable, originalData);
-        }
-
-        bool transformedVariablePending = transformationsStack.Any(x => x.OriginalVariable == transformation.TransformedVariable || x.TransformedVariable == transformation.TransformedVariable);
-        if (removeVirtualVariables && !transformedVariablePending)
-          modifiableDataset.RemoveVariable(transformation.TransformedVariable);
-      }
-
-      return modifiableDataset;
-    }
   }
 }
Index: /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/DataAnalysisTransformation.cs
===================================================================
--- /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/DataAnalysisTransformation.cs	(revision 15883)
+++ /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/DataAnalysisTransformation.cs	(revision 15884)
@@ -20,4 +20,7 @@
 #endregion
 
+using System;
+using System.Collections.Generic;
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -67,6 +70,5 @@
 
     private DataAnalysisTransformation(DataAnalysisTransformation original, Cloner cloner)
-      : base(original, cloner) {
-    }
+      : base(original, cloner) { }
 
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -84,4 +86,189 @@
       return $"{Transformation} ({OriginalVariable} -> {TransformedVariable})";
     }
+
+    #region Transformation
+
+    #region Variable Extension & Reduction
+    // originals => include extended
+    public static IEnumerable<string> ExtendVariables(IEnumerable<string> variables, IEnumerable<IDataAnalysisTransformation> transformations) {
+      return GetTransitiveVariables(variables, transformations);
+    }
+
+    // extended => originals
+    public static IEnumerable<string> ReduceVariables(IEnumerable<string> variables, IEnumerable<IDataAnalysisTransformation> transformations) {
+      var originalVariables = new HashSet<string>();
+      foreach (var variable in variables)
+        originalVariables.Add(GetLastTransitiveVariable(variable, transformations, inverse: true));
+      return originalVariables;
+    }
+
+    public static IEnumerable<string> GetTransitiveVariables(IEnumerable<string> variables, IEnumerable<IDataAnalysisTransformation> transformations, bool inverse = false) {
+      var reachableVariables = new HashSet<string>(variables);
+      if (inverse) transformations = transformations.Reverse();
+      foreach (var transformation in transformations) {
+        var source = inverse ? transformation.TransformedVariable : transformation.OriginalVariable;
+        var target = inverse ? transformation.OriginalVariable : transformation.TransformedVariable;
+        if (reachableVariables.Contains(source))
+          reachableVariables.Add(target);
+      }
+
+      return reachableVariables;
+    }
+
+    public static string GetLastTransitiveVariable(string variable, IEnumerable<IDataAnalysisTransformation> transformations, bool inverse = false) {
+      if (inverse) transformations = transformations.Reverse();
+      foreach (var transformation in transformations) {
+        var source = inverse ? transformation.TransformedVariable : transformation.OriginalVariable;
+        var target = inverse ? transformation.OriginalVariable : transformation.TransformedVariable;
+        if (variable == source)
+          variable = target;
+      }
+
+      return variable;
+    }
+    #endregion
+
+    #region Transform Dataset
+    public static IDataset Transform(IDataset dataset, IEnumerable<IDataAnalysisTransformation> transformations) {
+      var modifiableDataset = ((Dataset)dataset).ToModifiable();
+
+      foreach (var transformation in transformations) {
+        var trans = (ITransformation<double>)transformation.Transformation;
+
+        var originalData = modifiableDataset.GetDoubleValues(transformation.OriginalVariable);
+        //if (!trans.Check(originalData, out string errorMessage))
+        //  throw new InvalidOperationException($"Cannot estimate Values, Transformation is invalid: {errorMessage}");
+        // TODO: check was already called before configure (in preprocessing)
+        // TODO: newly specified data might not pass the check but it does not matter because the data is not configured with
+        // e.g. impact calculation -> replacement=most common -> originalMean is zero
+
+        var transformedData = trans.Apply(originalData).ToList();
+        if (modifiableDataset.VariableNames.Contains(transformation.TransformedVariable))
+          modifiableDataset.ReplaceVariable(transformation.TransformedVariable, transformedData);
+        else
+          modifiableDataset.AddVariable(transformation.TransformedVariable, transformedData);
+      }
+
+      return modifiableDataset; // TODO: to regular dataset?
+    }
+
+    public static IDataset InverseTransform(IDataset dataset, IEnumerable<IDataAnalysisTransformation> transformations, bool removeVirtualVariables = true) {
+      var modifiableDataset = ((Dataset)dataset).ToModifiable();
+
+      var transformationsStack = new Stack<IDataAnalysisTransformation>(transformations);
+      while (transformationsStack.Any()) {
+        var transformation = transformationsStack.Pop();
+        var trans = (ITransformation<double>)transformation.Transformation;
+
+        var prevTransformations = transformations.Except(transformationsStack);
+        bool originalWasChanged = prevTransformations.Any(x => x.TransformedVariable == transformation.OriginalVariable);
+        if (originalWasChanged) {
+          var transformedData = modifiableDataset.GetDoubleValues(transformation.TransformedVariable);
+
+          var originalData = trans.InverseApply(transformedData).ToList();
+          modifiableDataset.ReplaceVariable(transformation.OriginalVariable, originalData);
+        }
+      }
+
+      if (removeVirtualVariables) {
+        var originalVariables = ReduceVariables(dataset.VariableNames, transformations);
+        var virtualVariables = dataset.VariableNames.Except(originalVariables);
+        foreach (var virtualVariable in virtualVariables)
+          modifiableDataset.RemoveVariable(virtualVariable);
+      }
+
+      return modifiableDataset; // TODO: to regular dataset?
+    }
+    #endregion
+
+    #region Transform ProblemData
+    public static IDataAnalysisProblemData ApplyTransformations(IDataAnalysisProblemData problemData) {
+      var newDataset = Transform(problemData.Dataset, problemData.Transformations);
+      var extendedInputs = ExtendVariables(problemData.AllowedInputVariables, problemData.Transformations);
+
+      return CreateNewProblemData(problemData, newDataset, extendedInputs, inverse: false);
+    }
+
+    public static IDataAnalysisProblemData InverseApplyTransformations(IDataAnalysisProblemData problemData) {
+      var newDataset = InverseTransform(problemData.Dataset, problemData.Transformations);
+      var reducedInputs = ReduceVariables(problemData.AllowedInputVariables, problemData.Transformations);
+
+      return CreateNewProblemData(problemData, newDataset, reducedInputs, inverse: true);
+    }
+
+    private static IDataAnalysisProblemData CreateNewProblemData(IDataAnalysisProblemData problemData, IDataset dataset, IEnumerable<string> inputs, bool inverse = false) {
+      IDataAnalysisProblemData newProblemData;
+      if (problemData is IRegressionProblemData regressionProblemData) {
+        var newTargetVariable = GetLastTransitiveVariable(regressionProblemData.TargetVariable, problemData.Transformations, inverse);
+        newProblemData = new RegressionProblemData(dataset, inputs, newTargetVariable, problemData.Transformations);
+      } else if (problemData is IClassificationProblemData classificationProblemData) {
+        newProblemData = new ClassificationProblemData(dataset, inputs, classificationProblemData.TargetVariable, problemData.Transformations);
+      } else throw new NotSupportedException("Type of ProblemData not supported");
+
+      newProblemData.TrainingPartition.Start = problemData.TrainingPartition.Start;
+      newProblemData.TrainingPartition.End = problemData.TrainingPartition.End;
+      newProblemData.TestPartition.Start = problemData.TestPartition.Start;
+      newProblemData.TestPartition.End = problemData.TestPartition.End;
+
+      return newProblemData;
+    }
+    #endregion
+
+    #region Transform Model
+    public static IDataAnalysisTransformationModel CreateTransformationIntegratedModel(IDataAnalysisModel model, IEnumerable<IDataAnalysisTransformation> transformations) {
+      if (model is IDataAnalysisTransformationModel)
+        throw new InvalidOperationException("Model already is a transformation model.");
+
+      switch (model) {
+        case ITimeSeriesPrognosisModel timeSeriesPrognosisModel:
+          return new TimeSeriesPrognosisTransformationModel(timeSeriesPrognosisModel, transformations);
+        case IRegressionModel regressionModel:
+          return new RegressionTransformationModel(regressionModel, transformations);
+        case IClassificationModel classificationModel:
+          return new ClassificationTransformationModel(classificationModel, transformations);
+        case IClusteringModel clusteringModel:
+          return new ClusteringTransformationModel(clusteringModel, transformations);
+        default:
+          throw new NotSupportedException("Type of the model is not supported;");
+      }
+    }
+
+    public static IDataAnalysisModel RestoreTrainedModel(IDataAnalysisModel transformationModel, IEnumerable<IDataAnalysisTransformation> transformations) {
+      if (!(transformationModel is IDataAnalysisTransformationModel model))
+        throw new InvalidOperationException("Cannot restore because model is not a TransformationModel");
+      return model.OriginalModel;
+    }
+    #endregion
+
+    #region Transform Solution
+    public static IDataAnalysisSolution TransformSolution(IDataAnalysisSolution solution) {
+      var transformations = solution.ProblemData.Transformations;
+
+      var model = solution.Model is IDataAnalysisTransformationModel // TODO: what if model is a integrated sym-reg model?
+        ? RestoreTrainedModel(solution.Model, transformations)
+        : CreateTransformationIntegratedModel(solution.Model, transformations);
+
+      var data = solution.Model is IDataAnalysisTransformationModel
+        ? ApplyTransformations(solution.ProblemData) // original -> transformed
+        : InverseApplyTransformations(solution.ProblemData); // transformed -> original
+
+      return CreateSolution(model, data);
+    }
+
+    private static IDataAnalysisSolution CreateSolution(IDataAnalysisModel model, IDataAnalysisProblemData problemData) {
+      switch (model) {
+        case ITimeSeriesPrognosisModel timeSeriesPrognosisModel:
+          return timeSeriesPrognosisModel.CreateTimeSeriesPrognosisSolution((ITimeSeriesPrognosisProblemData)problemData);
+        case IRegressionModel regressionModel:
+          return regressionModel.CreateRegressionSolution((IRegressionProblemData)problemData);
+        case IClassificationModel classificationModel:
+          return classificationModel.CreateClassificationSolution((IClassificationProblemData)problemData);
+        default:
+          throw new NotSupportedException("Cannot create Solution of the model type.");
+      }
+    }
+    #endregion
+
+    #endregion
   }
 }
Index: /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/DataAnalysisTransformationModel.cs
===================================================================
--- /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/DataAnalysisTransformationModel.cs	(revision 15883)
+++ /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/DataAnalysisTransformationModel.cs	(revision 15884)
@@ -35,4 +35,8 @@
     public IDataAnalysisModel OriginalModel { get; protected set; }
 
+    IEnumerable<IDataAnalysisTransformation> IDataAnalysisTransformationModel.InputTransformations {
+      get { return InputTransformations; }
+    }
+
     [Storable]
     public ReadOnlyItemList<IDataAnalysisTransformation> InputTransformations { get; protected set; }
@@ -55,12 +59,12 @@
 
     public override IEnumerable<string> VariablesUsedForPrediction {
-      get { return OriginalModel.VariablesUsedForPrediction; /* TODO: reduce extend-inputs */}
+      get { return DataAnalysisTransformation.ReduceVariables(OriginalModel.VariablesUsedForPrediction, InputTransformations); }
     }
 
     #region Constructor, Cloning & Persistence
     protected DataAnalysisTransformationModel(IDataAnalysisModel originalModel, IEnumerable<IDataAnalysisTransformation> transformations)
-      : base(originalModel.Name) {
+      : base("Transformation Model " + originalModel.Name) {
       OriginalModel = originalModel;
-      var transitiveInputs = CalculateTransitiveVariables(originalModel.VariablesUsedForPrediction, transformations);
+      var transitiveInputs = DataAnalysisTransformation.GetTransitiveVariables(originalModel.VariablesUsedForPrediction, transformations, inverse: true);
       InputTransformations = new ItemList<IDataAnalysisTransformation>(transformations.Where(t => transitiveInputs.Contains(t.OriginalVariable))).AsReadOnly();
       TargetTransformations = new ReadOnlyItemList<IDataAnalysisTransformation>();
@@ -80,65 +84,4 @@
     #endregion
 
-    // extended -> include originals
-    public static ISet<string> CalculateTransitiveVariables(IEnumerable<string> inputVariables, IEnumerable<IDataAnalysisTransformation> transformations) {
-      var transitiveInputs = new HashSet<string>(inputVariables);
-
-      foreach (var transformation in transformations.Reverse()) {
-        if (transitiveInputs.Contains(transformation.TransformedVariable)) {
-          transitiveInputs.Add(transformation.OriginalVariable);
-        }
-      }
-
-      return transitiveInputs;
-    }
-    // originals => include extended
-    public static IEnumerable<string> ExtendInputVariables(IEnumerable<string> oldInputVariables, IEnumerable<IDataAnalysisTransformation> transformations) {
-      var inputs = new HashSet<string>(oldInputVariables);
-
-      foreach (var transformation in transformations) {
-        if (inputs.Contains(transformation.OriginalVariable))
-          inputs.Add(transformation.TransformedVariable);
-      }
-
-      return inputs;
-    }
-    [Obsolete]
-    public static IEnumerable<string> RemoveVirtualVariables(IEnumerable<string> variables, IEnumerable<IDataAnalysisTransformation> transformations) {
-      var remainingVariables = new HashSet<string>(variables);
-
-      var transformationsStack = new Stack<IDataAnalysisTransformation>(transformations);
-
-      while (transformationsStack.Any()) {
-        var transformation = transformationsStack.Pop();
-
-
-        bool transformedVariablePending = transformationsStack.Any(x => x.OriginalVariable == transformation.TransformedVariable);
-        if (!transformedVariablePending)
-          remainingVariables.Remove(transformation.TransformedVariable);
-      }
-
-      return remainingVariables;
-    }
-
-    public static IDataset Transform(IDataset dataset, IEnumerable<IDataAnalysisTransformation> transformations) {
-      var modifiableDataset = ((Dataset)dataset).ToModifiable();
-
-      foreach (var transformation in transformations) {
-        var trans = (ITransformation<double>)transformation.Transformation;
-
-        var originalData = modifiableDataset.GetDoubleValues(transformation.OriginalVariable);
-        if (!trans.Check(originalData, out string errorMessage))
-          throw new InvalidOperationException($"Cannot estimate Values, Transformation is invalid: {errorMessage}");
-
-        var transformedData = trans.Apply(originalData).ToList();
-        if (modifiableDataset.VariableNames.Contains(transformation.TransformedVariable))
-          modifiableDataset.ReplaceVariable(transformation.TransformedVariable, transformedData);
-        else
-          modifiableDataset.AddVariable(transformation.TransformedVariable, transformedData);
-      }
-
-      return modifiableDataset;
-    }
-
     #region Events
     public event EventHandler TargetVariableChanged;
Index: /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionProblemData.cs
===================================================================
--- /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionProblemData.cs	(revision 15883)
+++ /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionProblemData.cs	(revision 15884)
@@ -180,18 +180,4 @@
       base.AdjustProblemDataProperties(problemData);
     }
-
-    public override IDataAnalysisProblemData Transform() {
-      var transformedProblemData = (IRegressionProblemData)base.Transform();
-      var targetVariable = RegressionTransformationModel.GetTransformedTragetVariable(TargetVariable, Transformations);
-      transformedProblemData.TargetVariable = targetVariable;
-      return transformedProblemData;
-    }
-
-    public override IDataAnalysisProblemData InverseTransform() {
-      var transformedProblemData = (IRegressionProblemData)base.InverseTransform();
-      var targetVariable = RegressionTransformationModel.GetOriginalTragetVariable(TargetVariable, Transformations);
-      transformedProblemData.TargetVariable = targetVariable;
-      return transformedProblemData;
-    }
   }
 }
Index: /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionTransformationModel.cs
===================================================================
--- /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionTransformationModel.cs	(revision 15883)
+++ /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionTransformationModel.cs	(revision 15884)
@@ -20,5 +20,4 @@
 #endregion
 
-using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -36,15 +35,18 @@
     }
 
+    IEnumerable<IDataAnalysisTransformation> IRegressionTransformationModel.TargetTransformations {
+      get { return TargetTransformations; }
+    }
+
     #region Constructor, Cloning & Persistence
     public RegressionTransformationModel(IRegressionModel originalModel, IEnumerable<IDataAnalysisTransformation> transformations)
       : base(originalModel, transformations) {
-      var transitiveTargets = CalculateTransitiveVariables(new[] { originalModel.TargetVariable }, transformations);
+      var transitiveTargets = DataAnalysisTransformation.GetTransitiveVariables(new[] { originalModel.TargetVariable }, transformations, inverse: true).ToList();
       TargetTransformations = new ItemList<IDataAnalysisTransformation>(transformations.Where(t => transitiveTargets.Contains(t.OriginalVariable))).AsReadOnly();
-      TargetVariable = GetOriginalTragetVariable(originalModel.TargetVariable, TargetTransformations);
+      TargetVariable = DataAnalysisTransformation.GetLastTransitiveVariable(originalModel.TargetVariable, TargetTransformations, inverse: true);
     }
 
     protected RegressionTransformationModel(RegressionTransformationModel original, Cloner cloner)
       : base(original, cloner) {
-      
     }
 
@@ -59,6 +61,7 @@
 
     public virtual IEnumerable<double> GetEstimatedValues(IDataset dataset, IEnumerable<int> rows) {
-      var estimates = OriginalModel.GetEstimatedValues(Transform(dataset, InputTransformations), rows);
-      return InverseTransform(estimates, TargetTransformations, OriginalModel.TargetVariable);
+      var transformedInput = DataAnalysisTransformation.Transform(dataset, InputTransformations);
+      var estimates = OriginalModel.GetEstimatedValues(transformedInput, rows);
+      return InverseTransform(estimates, TargetTransformations);
     }
 
@@ -67,37 +70,10 @@
     }
 
-    public static IEnumerable<double> InverseTransform(IEnumerable<double> data, IEnumerable<IDataAnalysisTransformation> transformations, string targetVariable) {
-      var estimates = data.ToList();
-
-      foreach (var transformation in transformations.Reverse()) {
-        if (transformation.TransformedVariable == targetVariable) {
-          var trans = (ITransformation<double>)transformation.Transformation;
-
-          estimates = trans.InverseApply(estimates).ToList();
-
-          // setup next iteration
-          targetVariable = transformation.OriginalVariable;
-        }
+    protected static IEnumerable<double> InverseTransform(IEnumerable<double> data, IEnumerable<IDataAnalysisTransformation> transformations) {
+      foreach (var transformation in transformations.Reverse()) { // TargetTransformations only contains only relevant transformations
+        var trans = (ITransformation<double>)transformation.Transformation;
+        data = trans.InverseApply(data).ToList();
       }
-
-      return estimates;
-    }
-
-    public static string GetTransformedTragetVariable(string originalTarget, IEnumerable<IDataAnalysisTransformation> transformations) {
-      var transformedTarget = originalTarget;
-      foreach (var transformation in transformations) {
-        if (transformation.OriginalVariable == transformedTarget)
-          transformedTarget = transformation.TransformedVariable;
-      }
-      return transformedTarget;
-    }
-
-    public static string GetOriginalTragetVariable(string transformedTarget, IEnumerable<IDataAnalysisTransformation> transformations) {
-      var originalTarget = transformedTarget;
-      foreach (var transformation in transformations.Reverse()) {
-        if (transformation.TransformedVariable == originalTarget)
-          originalTarget = transformation.OriginalVariable;
-      }
-      return originalTarget;
+      return data;
     }
   }
Index: /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/TimeSeriesPrognosis/Models/TimeSeriesPrognosisTransformationModel.cs
===================================================================
--- /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/TimeSeriesPrognosis/Models/TimeSeriesPrognosisTransformationModel.cs	(revision 15883)
+++ /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/TimeSeriesPrognosis/Models/TimeSeriesPrognosisTransformationModel.cs	(revision 15884)
@@ -53,7 +53,9 @@
     #endregion
 
+
     public IEnumerable<IEnumerable<double>> GetPrognosedValues(IDataset dataset, IEnumerable<int> rows, IEnumerable<int> horizons) {
-      var estimates = OriginalModel.GetPrognosedValues(Transform(dataset, InputTransformations), rows, horizons);
-      return estimates.Select(x => InverseTransform(x, TargetTransformations, TargetVariable)); // TODO: transform the whole horizon?
+      var transformedInput = DataAnalysisTransformation.Transform(dataset, InputTransformations);
+      var estimates = OriginalModel.GetPrognosedValues(transformedInput, rows, horizons);
+      return estimates.Select(x => InverseTransform(x, TargetTransformations));
     }
 
Index: /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/LinearTransformation.cs
===================================================================
--- /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/LinearTransformation.cs	(revision 15883)
+++ /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/LinearTransformation.cs	(revision 15884)
@@ -20,4 +20,5 @@
 #endregion
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -46,5 +47,5 @@
     public double Slope {
       get { return SlopeParameter.Value.Value; }
-      set { SlopeParameter.Value.Value = value; } //TODO: check for != 0?
+      set { SlopeParameter.Value.Value = value; }
     }
 
@@ -85,8 +86,14 @@
 
     public static IEnumerable<double> Apply(IEnumerable<double> data, double slope = 1.0, double intercept = 0.0) {
+      if (slope.IsAlmost(0.0))
+        throw new InvalidOperationException($"Cannot transform with a {nameof(slope)} of zero because inverse transformation would be invalid.");
+
       return data.Select(x => slope * x + intercept);
     }
 
     public static IEnumerable<double> InverseApply(IEnumerable<double> data, double slope = 1.0, double intercept = 0.0) {
+      if (slope.IsAlmost(0.0))
+        throw new InvalidOperationException($"Cannot inverse transform with a {nameof(slope)} of zero.");
+
       return data.Select(x => (x - intercept) / slope);
     }
Index: /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/ZNormalizationTransformation.cs
===================================================================
--- /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/ZNormalizationTransformation.cs	(revision 15883)
+++ /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Transformations/ZNormalizationTransformation.cs	(revision 15884)
@@ -20,4 +20,5 @@
 #endregion
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -97,12 +98,13 @@
 
     public override void Configure(IEnumerable<double> data) {
-      OriginalMean = data.Average();
-      OriginalStandardDeviation = data.StandardDeviationPop();
+      Configure(data, out double originalMean, out double originalStandardDeviation);
+      OriginalMean = originalMean;
+      OriginalStandardDeviation = originalStandardDeviation;
       base.Configure(data);
     }
 
     public override IEnumerable<double> Apply(IEnumerable<double> data) {
-      if (double.IsNaN(OriginalMean) || double.IsNaN(OriginalStandardDeviation)) //TODO isConfigured field?
-        Configure(data);
+      if (double.IsNaN(OriginalMean) || double.IsNaN(OriginalStandardDeviation))
+        throw new InvalidOperationException("Transformation is not configured");
 
       return Apply(data, TargetMean, TargetStandardDeviation, OriginalMean, OriginalStandardDeviation);
@@ -110,7 +112,15 @@
 
     public override IEnumerable<double> InverseApply(IEnumerable<double> data) {
+      if (double.IsNaN(OriginalMean) || double.IsNaN(OriginalStandardDeviation))
+        throw new InvalidOperationException("Transformation is not configured");
+
       return InverseApply(data, TargetMean, TargetStandardDeviation, OriginalMean, OriginalStandardDeviation);
     }
 
+
+    public static void Configure(IEnumerable<double> data, out double originalMean, out double originalStandardDeviation) {
+      originalMean = data.Average();
+      originalStandardDeviation = data.StandardDeviationPop();
+    }
 
     public static IEnumerable<double> Apply(IEnumerable<double> data, double targetMean, double targetStandardDeviation, double originalMean = double.NaN, double originalStandardDeviation = double.NaN) {
Index: /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IDataAnalysisProblemData.cs
===================================================================
--- /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IDataAnalysisProblemData.cs	(revision 15883)
+++ /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IDataAnalysisProblemData.cs	(revision 15884)
@@ -44,6 +44,4 @@
 
     IEnumerable<IDataAnalysisTransformation> Transformations { get; }
-    IDataAnalysisProblemData Transform();
-    IDataAnalysisProblemData InverseTransform();
 
     bool IsTrainingSample(int index);
Index: /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IDataAnalysisTransformationModel.cs
===================================================================
--- /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IDataAnalysisTransformationModel.cs	(revision 15883)
+++ /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IDataAnalysisTransformationModel.cs	(revision 15884)
@@ -20,5 +20,5 @@
 #endregion
 
-using HeuristicLab.Core;
+using System.Collections.Generic;
 
 namespace HeuristicLab.Problems.DataAnalysis {
@@ -28,8 +28,6 @@
     /// <summary>
     /// Transformations that are used on the model's inputs.
-    /// </summary>                                                                      
-    ReadOnlyItemList<IDataAnalysisTransformation> InputTransformations { get; }  // TODO: IReadonlyList<>?
-
-    ReadOnlyItemList<IDataAnalysisTransformation> TargetTransformations { get; } // TODO: to Regression/Classification interface?
+    /// </summary>
+    IEnumerable<IDataAnalysisTransformation> InputTransformations { get; }
   }
 }
Index: /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/Regression/IRegressionTransformationModel.cs
===================================================================
--- /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/Regression/IRegressionTransformationModel.cs	(revision 15883)
+++ /branches/2906_Transformations/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/Regression/IRegressionTransformationModel.cs	(revision 15884)
@@ -20,9 +20,11 @@
 #endregion
 
-using HeuristicLab.Core;
+using System.Collections.Generic;
 
 namespace HeuristicLab.Problems.DataAnalysis {
   public interface IRegressionTransformationModel : IDataAnalysisTransformationModel, IRegressionModel {
     new IRegressionModel OriginalModel { get; }
+
+    IEnumerable<IDataAnalysisTransformation> TargetTransformations { get; }
   }
 }
