Index: /branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis.Views/3.4/HeuristicLab.Problems.DataAnalysis.Views-3.4.csproj
===================================================================
--- /branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis.Views/3.4/HeuristicLab.Problems.DataAnalysis.Views-3.4.csproj	(revision 17606)
+++ /branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis.Views/3.4/HeuristicLab.Problems.DataAnalysis.Views-3.4.csproj	(revision 17607)
@@ -315,4 +315,10 @@
       <DependentUpon>IntervalCollectionView.cs</DependentUpon>
     </Compile>
+    <Compile Include="IntervalConstraintView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="IntervalConstraintView.Designer.cs">
+      <DependentUpon>IntervalConstraintView.cs</DependentUpon>
+    </Compile>
     <Compile Include="MenuItems\ChangeDataOfOptimizersMenuItem.cs" />
     <Compile Include="MenuItems\ShrinkDataAnalysisRunsMenuItem.cs" />
@@ -324,4 +330,10 @@
     </Compile>
     <Compile Include="Plugin.cs" />
+    <Compile Include="ProblemDataConstraintView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="ProblemDataConstraintView.Designer.cs">
+      <DependentUpon>ProblemDataConstraintView.cs</DependentUpon>
+    </Compile>
     <Compile Include="ProblemDataView.cs">
       <SubType>UserControl</SubType>
Index: /branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis.Views/3.4/IntervalConstraintView.Designer.cs
===================================================================
--- /branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis.Views/3.4/IntervalConstraintView.Designer.cs	(revision 17607)
+++ /branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis.Views/3.4/IntervalConstraintView.Designer.cs	(revision 17607)
@@ -0,0 +1,228 @@
+﻿namespace HeuristicLab.Problems.DataAnalysis.Views {
+  partial class IntervalConstraintView {
+    /// <summary> 
+    /// Required designer variable.
+    /// </summary>
+    private System.ComponentModel.IContainer components = null;
+
+    /// <summary> 
+    /// Clean up any resources being used.
+    /// </summary>
+    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+    protected override void Dispose(bool disposing) {
+        if (disposing && (components != null)) {
+            components.Dispose();
+        }
+        base.Dispose(disposing);
+    }
+
+    #region Component Designer generated code
+
+    /// <summary> 
+    /// Required method for Designer support - do not modify 
+    /// the contents of this method with the code editor.
+    /// </summary>
+    private void InitializeComponent() {
+      this.components = new System.ComponentModel.Container();
+      this.lowerboundLabel = new System.Windows.Forms.Label();
+      this.upperboundLabel = new System.Windows.Forms.Label();
+      this.variableLabel = new System.Windows.Forms.Label();
+      this.numberderivationLabel = new System.Windows.Forms.Label();
+      this.upperboundInput = new System.Windows.Forms.TextBox();
+      this.lowerboundInput = new System.Windows.Forms.TextBox();
+      this.variableInput = new System.Windows.Forms.TextBox();
+      this.groupBox1 = new System.Windows.Forms.GroupBox();
+      this.enabledLabel = new System.Windows.Forms.Label();
+      this.label1 = new System.Windows.Forms.Label();
+      this.numberderivationInput = new System.Windows.Forms.ComboBox();
+      this.ischeckedCheckBox = new System.Windows.Forms.CheckBox();
+      this.expressionInput = new System.Windows.Forms.TextBox();
+      this.expressionLabel = new System.Windows.Forms.Label();
+      this.errorProvider = new System.Windows.Forms.ErrorProvider(this.components);
+      this.groupBox1.SuspendLayout();
+      ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).BeginInit();
+      this.SuspendLayout();
+      // 
+      // lowerboundLabel
+      // 
+      this.lowerboundLabel.AutoSize = true;
+      this.lowerboundLabel.Location = new System.Drawing.Point(8, 101);
+      this.lowerboundLabel.Name = "lowerboundLabel";
+      this.lowerboundLabel.Size = new System.Drawing.Size(90, 17);
+      this.lowerboundLabel.TabIndex = 2;
+      this.lowerboundLabel.Text = "Lowerbound:";
+      // 
+      // upperboundLabel
+      // 
+      this.upperboundLabel.AutoSize = true;
+      this.upperboundLabel.Location = new System.Drawing.Point(8, 126);
+      this.upperboundLabel.Name = "upperboundLabel";
+      this.upperboundLabel.Size = new System.Drawing.Size(91, 17);
+      this.upperboundLabel.TabIndex = 3;
+      this.upperboundLabel.Text = "Upperbound:";
+      // 
+      // variableLabel
+      // 
+      this.variableLabel.AutoSize = true;
+      this.variableLabel.Location = new System.Drawing.Point(8, 47);
+      this.variableLabel.Name = "variableLabel";
+      this.variableLabel.Size = new System.Drawing.Size(64, 17);
+      this.variableLabel.TabIndex = 7;
+      this.variableLabel.Text = "Variable:";
+      // 
+      // numberderivationLabel
+      // 
+      this.numberderivationLabel.AutoSize = true;
+      this.numberderivationLabel.Location = new System.Drawing.Point(8, 74);
+      this.numberderivationLabel.Name = "numberderivationLabel";
+      this.numberderivationLabel.Size = new System.Drawing.Size(84, 17);
+      this.numberderivationLabel.TabIndex = 8;
+      this.numberderivationLabel.Text = "#Derivation:";
+      // 
+      // upperboundInput
+      // 
+      this.upperboundInput.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
+            | System.Windows.Forms.AnchorStyles.Right)));
+      this.upperboundInput.Location = new System.Drawing.Point(108, 123);
+      this.upperboundInput.Name = "upperboundInput";
+      this.upperboundInput.Size = new System.Drawing.Size(473, 22);
+      this.upperboundInput.TabIndex = 11;
+      this.upperboundInput.Validating += new System.ComponentModel.CancelEventHandler(this.upperboundInput_Validating);
+      this.upperboundInput.Validated += new System.EventHandler(this.upperboundInput_Validated);
+      // 
+      // lowerboundInput
+      // 
+      this.lowerboundInput.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
+            | System.Windows.Forms.AnchorStyles.Right)));
+      this.lowerboundInput.Location = new System.Drawing.Point(108, 98);
+      this.lowerboundInput.Name = "lowerboundInput";
+      this.lowerboundInput.Size = new System.Drawing.Size(473, 22);
+      this.lowerboundInput.TabIndex = 12;
+      this.lowerboundInput.Validating += new System.ComponentModel.CancelEventHandler(this.lowerboundInput_Validating);
+      this.lowerboundInput.Validated += new System.EventHandler(this.lowerboundInput_Validated);
+      // 
+      // variableInput
+      // 
+      this.variableInput.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
+            | System.Windows.Forms.AnchorStyles.Right)));
+      this.variableInput.Location = new System.Drawing.Point(108, 44);
+      this.variableInput.Name = "variableInput";
+      this.variableInput.Size = new System.Drawing.Size(473, 22);
+      this.variableInput.TabIndex = 15;
+      // 
+      // groupBox1
+      // 
+      this.groupBox1.Controls.Add(this.enabledLabel);
+      this.groupBox1.Controls.Add(this.label1);
+      this.groupBox1.Controls.Add(this.numberderivationInput);
+      this.groupBox1.Controls.Add(this.ischeckedCheckBox);
+      this.groupBox1.Controls.Add(this.expressionInput);
+      this.groupBox1.Controls.Add(this.expressionLabel);
+      this.groupBox1.Controls.Add(this.variableInput);
+      this.groupBox1.Controls.Add(this.lowerboundInput);
+      this.groupBox1.Controls.Add(this.upperboundInput);
+      this.groupBox1.Controls.Add(this.numberderivationLabel);
+      this.groupBox1.Controls.Add(this.variableLabel);
+      this.groupBox1.Controls.Add(this.upperboundLabel);
+      this.groupBox1.Controls.Add(this.lowerboundLabel);
+      this.groupBox1.Dock = System.Windows.Forms.DockStyle.Fill;
+      this.groupBox1.Location = new System.Drawing.Point(0, 0);
+      this.groupBox1.Name = "groupBox1";
+      this.groupBox1.Size = new System.Drawing.Size(587, 380);
+      this.groupBox1.TabIndex = 0;
+      this.groupBox1.TabStop = false;
+      this.groupBox1.Text = "Interval Constraints Detail";
+      // 
+      // enabledLabel
+      // 
+      this.enabledLabel.AutoSize = true;
+      this.enabledLabel.Location = new System.Drawing.Point(8, 153);
+      this.enabledLabel.Name = "enabledLabel";
+      this.enabledLabel.Size = new System.Drawing.Size(64, 17);
+      this.enabledLabel.TabIndex = 29;
+      this.enabledLabel.Text = "Enabled:";
+      // 
+      // label1
+      // 
+      this.label1.AutoSize = true;
+      this.label1.Location = new System.Drawing.Point(11, -105);
+      this.label1.Name = "label1";
+      this.label1.Size = new System.Drawing.Size(64, 17);
+      this.label1.TabIndex = 28;
+      this.label1.Text = "Enabled:";
+      // 
+      // numberderivationInput
+      // 
+      this.numberderivationInput.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
+            | System.Windows.Forms.AnchorStyles.Right)));
+      this.numberderivationInput.FormattingEnabled = true;
+      this.numberderivationInput.Location = new System.Drawing.Point(108, 71);
+      this.numberderivationInput.Name = "numberderivationInput";
+      this.numberderivationInput.Size = new System.Drawing.Size(473, 24);
+      this.numberderivationInput.TabIndex = 27;
+      this.numberderivationInput.SelectedIndexChanged += new System.EventHandler(this.numberderivationInput_SelectedIndexChanged);
+      // 
+      // ischeckedCheckBox
+      // 
+      this.ischeckedCheckBox.AutoSize = true;
+      this.ischeckedCheckBox.Location = new System.Drawing.Point(108, 154);
+      this.ischeckedCheckBox.Name = "ischeckedCheckBox";
+      this.ischeckedCheckBox.Size = new System.Drawing.Size(18, 17);
+      this.ischeckedCheckBox.TabIndex = 26;
+      this.ischeckedCheckBox.UseVisualStyleBackColor = true;
+      this.ischeckedCheckBox.CheckedChanged += new System.EventHandler(this.ischeckedCheckBox_CheckedChanged);
+      // 
+      // expressionInput
+      // 
+      this.expressionInput.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
+            | System.Windows.Forms.AnchorStyles.Right)));
+      this.expressionInput.Location = new System.Drawing.Point(108, 19);
+      this.expressionInput.Name = "expressionInput";
+      this.expressionInput.Size = new System.Drawing.Size(473, 22);
+      this.expressionInput.TabIndex = 25;
+      // 
+      // expressionLabel
+      // 
+      this.expressionLabel.AutoSize = true;
+      this.expressionLabel.Location = new System.Drawing.Point(8, 22);
+      this.expressionLabel.Name = "expressionLabel";
+      this.expressionLabel.Size = new System.Drawing.Size(81, 17);
+      this.expressionLabel.TabIndex = 24;
+      this.expressionLabel.Text = "Expression:";
+      // 
+      // errorProvider
+      // 
+      this.errorProvider.ContainerControl = this;
+      this.errorProvider.RightToLeft = true;
+      // 
+      // IntervalConstraintView
+      // 
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
+      this.Controls.Add(this.groupBox1);
+      this.Name = "IntervalConstraintView";
+      this.Size = new System.Drawing.Size(587, 380);
+      this.groupBox1.ResumeLayout(false);
+      this.groupBox1.PerformLayout();
+      ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).EndInit();
+      this.ResumeLayout(false);
+    }
+
+    #endregion
+
+    private System.Windows.Forms.Label         lowerboundLabel;
+    private System.Windows.Forms.Label         upperboundLabel;
+    private System.Windows.Forms.Label         variableLabel;
+    private System.Windows.Forms.Label         numberderivationLabel;
+    private System.Windows.Forms.TextBox       upperboundInput;
+    private System.Windows.Forms.TextBox       lowerboundInput;
+    private System.Windows.Forms.TextBox       variableInput;
+    private System.Windows.Forms.GroupBox      groupBox1;
+    private System.Windows.Forms.TextBox       expressionInput;
+    private System.Windows.Forms.Label         expressionLabel;
+    private System.Windows.Forms.ErrorProvider errorProvider;
+    private System.Windows.Forms.CheckBox      ischeckedCheckBox;
+    private System.Windows.Forms.ComboBox      numberderivationInput;
+    private System.Windows.Forms.Label         label1;
+    private System.Windows.Forms.Label         enabledLabel;
+    }
+}
Index: /branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis.Views/3.4/IntervalConstraintView.cs
===================================================================
--- /branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis.Views/3.4/IntervalConstraintView.cs	(revision 17607)
+++ /branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis.Views/3.4/IntervalConstraintView.cs	(revision 17607)
@@ -0,0 +1,204 @@
+﻿#region License Information
+
+/* HeuristicLab
+ * Copyright (C) 2002-2019 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 System;
+using System.ComponentModel;
+using System.Windows.Forms;
+using HeuristicLab.Core.Views;
+using HeuristicLab.MainForm;
+
+namespace HeuristicLab.Problems.DataAnalysis.Views {
+  [View("Interval Constraint Detail View")]
+  [Content(typeof(IntervalConstraint), true)]
+  public sealed partial class IntervalConstraintView : ItemView {
+    public new IntervalConstraint Content {
+      get => (IntervalConstraint) base.Content;
+      set => base.Content = value;
+    }
+
+    public IntervalConstraintView() {
+      InitializeComponent();
+      int[] items = {1, 2, 3};
+      expressionInput.ReadOnly         = true;
+      numberderivationInput.DataSource = items;
+    }
+
+    protected override void OnContentChanged() {
+      base.OnContentChanged();
+      UpdateControls();
+    }
+
+    protected override void RegisterContentEvents() {
+      base.RegisterContentEvents();
+      Content.Changed += Content_Changed;
+    }
+
+    protected override void DeregisterContentEvents() {
+      Content.Changed -= Content_Changed;
+      base.DeregisterContentEvents();
+    }
+
+    protected override void SetEnabledStateOfControls() {
+      base.SetEnabledStateOfControls();
+      expressionInput.Enabled       = Content != null && !Locked && !ReadOnly;
+      variableInput.Enabled         = Content != null && !Locked && !ReadOnly;
+      numberderivationInput.Enabled = Content != null && !Locked && !ReadOnly;
+      lowerboundInput.Enabled       = Content != null && !Locked && !ReadOnly;
+      upperboundInput.Enabled       = Content != null && !Locked && !ReadOnly;
+      ischeckedCheckBox.Enabled     = Content != null && !Locked && !ReadOnly;
+    }
+
+
+    #region helpers
+
+    private static double ParseDoubleValue(string input, Control control, ErrorProvider errorProvider) {
+      input = input.ToLower();
+      switch (input) {
+        case "inf.":
+        case "+inf.":
+        case "Infinity":
+          return double.PositiveInfinity;
+        case "-inf.":
+        case "-Infinity":
+          return double.NegativeInfinity;
+        default: {
+          if (double.TryParse(input, out var value)) {
+            return value;
+          }
+
+          errorProvider.SetError(control, "Invalid Input: Value must be a double!");
+          return double.NaN;
+        }
+      }
+    }
+
+    private void UpdateControls() {
+      if (Content == null) {
+        expressionInput.Text = string.Empty;
+        lowerboundInput.Text = string.Empty;
+        upperboundInput.Text = string.Empty;
+        return;
+      }
+
+      expressionInput.Text = Content.Expression;
+      lowerboundInput.Text = Content.Interval.LowerBound.ToString();
+      upperboundInput.Text = Content.Interval.UpperBound.ToString();
+
+      variableInput.Text = Content.Variable;
+      if (!Content.IsDerivative) {
+        numberderivationInput.Enabled      = false;
+        numberderivationInput.SelectedItem = null;
+        numberderivationInput.Text         = "0";
+      }
+      else {
+        numberderivationLabel.Visible      = true;
+        numberderivationInput.Visible      = true;
+        numberderivationInput.Enabled      = true;
+        numberderivationInput.SelectedItem = Content.NumberOfDerivations;
+      }
+
+      ischeckedCheckBox.Checked = Content.Enabled;
+    }
+
+    #endregion
+
+    #region control event handlers
+
+    private void lowerboundInput_Validating(object sender, CancelEventArgs e) {
+      var value = ParseDoubleValue(lowerboundInput.Text, lowerboundInput, errorProvider);
+      if (double.IsNaN(value)) {
+        errorProvider.SetError(lowerboundInput, "Invalid Input: Lowerbound must be a double value!");
+        e.Cancel = true;
+        return;
+      }
+
+      if (value > Content.Interval.UpperBound) {
+        errorProvider.SetError(lowerboundInput, "Invalid Input: Lowerbound must be smaller than Upperbound!");
+        e.Cancel = true;
+        return;
+      }
+
+      errorProvider.SetError(lowerboundInput, string.Empty);
+      e.Cancel = false;
+    }
+
+    private void lowerboundInput_Validated(object sender, EventArgs e) {
+      var value =
+        ParseDoubleValue(lowerboundInput.Text, lowerboundInput, errorProvider);
+      if (!double.IsNaN(value)) Content.Interval = new Interval(value, Content.Interval.UpperBound);
+    }
+
+    private void upperboundInput_Validating(object sender, CancelEventArgs e) {
+      var value = ParseDoubleValue(upperboundInput.Text, upperboundInput, errorProvider);
+      if (double.IsNaN(value)) {
+        errorProvider.SetError(upperboundInput, "Invalid Input: Upperbound must be a double value!");
+        e.Cancel = true;
+        return;
+      }
+
+      if (value < Content.Interval.LowerBound) {
+        errorProvider.SetError(upperboundInput, "Invalid Input: Upperbound must be bigger than Lowerbound!");
+        e.Cancel = true;
+        return;
+      }
+
+      errorProvider.SetError(upperboundInput, string.Empty);
+      e.Cancel = false;
+    }
+
+    private void upperboundInput_Validated(object sender, EventArgs e) {
+      var value =
+        ParseDoubleValue(upperboundInput.Text, upperboundInput, errorProvider);
+      if (!double.IsNaN(value)) Content.Interval = new Interval(Content.Interval.LowerBound, value);
+    }
+
+    private void ischeckedCheckBox_CheckedChanged(object sender, EventArgs e) {
+      Content.Enabled = ischeckedCheckBox.Checked;
+    }
+
+    private void numberderivationInput_SelectedIndexChanged(object sender, EventArgs e) {
+      if (numberderivationInput.SelectedItem == null) {
+        Content.NumberOfDerivations   = 0;
+        numberderivationInput.Enabled = false;
+        return;
+      }
+
+      if ((int) numberderivationInput.SelectedItem == 1)
+        Content.NumberOfDerivations = 1;
+      else if ((int) numberderivationInput.SelectedItem == 2)
+        Content.NumberOfDerivations = 2;
+      else if ((int) numberderivationInput.SelectedItem == 3)
+        Content.NumberOfDerivations = 3;
+    }
+
+    #endregion
+
+    #region content event handlers
+
+    private void Content_Changed(object sender, EventArgs e) {
+      UpdateControls();
+    }
+
+    #endregion
+  }
+}
Index: /branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis.Views/3.4/ProblemDataConstraintView.Designer.cs
===================================================================
--- /branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis.Views/3.4/ProblemDataConstraintView.Designer.cs	(revision 17607)
+++ /branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis.Views/3.4/ProblemDataConstraintView.Designer.cs	(revision 17607)
@@ -0,0 +1,189 @@
+﻿#region License Information
+
+/* HeuristicLab
+ * Copyright (C) 2002-2019 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 System;
+using System.Drawing;
+using System.Windows.Forms;
+using HeuristicLab.Core.Views;
+
+namespace HeuristicLab.Problems.DataAnalysis.Views {
+  partial class ProblemDataConstraintView {
+    /// <summary> 
+    /// Required designer variable.
+    /// </summary>
+    private System.ComponentModel.IContainer components = null;
+
+    /// <summary> 
+    /// Clean up any resources being used.
+    /// </summary>
+    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+    protected override void Dispose(bool disposing) {
+        if (disposing && (components != null)) {
+            components.Dispose();
+        }
+        base.Dispose(disposing);
+    }
+
+    #region Component Designer generated code
+
+    /// <summary> 
+    /// Required method for Designer support - do not modify 
+    /// the contents of this method with the code editor.
+    /// </summary>
+    private void InitializeComponent() {
+      System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(ProblemDataConstraintView));
+      this.splitContainer1 = new System.Windows.Forms.SplitContainer();
+      this.groupBox1 = new System.Windows.Forms.GroupBox();
+      this.constraintsInput = new System.Windows.Forms.TextBox();
+      this.parseBtn = new System.Windows.Forms.Button();
+      this.errorOutput = new System.Windows.Forms.Label();
+      this.label1 = new System.Windows.Forms.Label();
+      this.intervalConstraintsView = new CheckedItemListView<IntervalConstraint>();
+      ((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).BeginInit();
+      this.splitContainer1.Panel1.SuspendLayout();
+      this.splitContainer1.Panel2.SuspendLayout();
+      this.splitContainer1.SuspendLayout();
+      this.groupBox1.SuspendLayout();
+      this.SuspendLayout();
+      // 
+      // splitContainer1
+      // 
+      this.splitContainer1.Dock = System.Windows.Forms.DockStyle.Fill;
+      this.splitContainer1.Location = new System.Drawing.Point(0, 0);
+      this.splitContainer1.Name = "splitContainer1";
+      // 
+      // splitContainer1.Panel1
+      // 
+      this.splitContainer1.Panel1.Controls.Add(this.groupBox1);
+      // 
+      // splitContainer1.Panel2
+      // 
+      this.splitContainer1.Panel2.Controls.Add(this.intervalConstraintsView);
+      this.splitContainer1.Size = new System.Drawing.Size(888, 629);
+      this.splitContainer1.SplitterDistance = 296;
+      this.splitContainer1.TabIndex = 0;
+      // 
+      // groupBox1
+      // 
+      this.groupBox1.Controls.Add(this.constraintsInput);
+      this.groupBox1.Controls.Add(this.parseBtn);
+      this.groupBox1.Controls.Add(this.errorOutput);
+      this.groupBox1.Controls.Add(this.label1);
+      this.groupBox1.Dock = System.Windows.Forms.DockStyle.Fill;
+      this.groupBox1.Location = new System.Drawing.Point(0, 0);
+      this.groupBox1.Name = "groupBox1";
+      this.groupBox1.Size = new System.Drawing.Size(296, 629);
+      this.groupBox1.TabIndex = 3;
+      this.groupBox1.TabStop = false;
+      this.groupBox1.Text = "Constraints Input";
+      // 
+      // constraintsInput
+      // 
+      this.constraintsInput.AcceptsTab = true;
+      this.constraintsInput.Dock = System.Windows.Forms.DockStyle.Fill;
+      this.constraintsInput.Location = new System.Drawing.Point(3, 185);
+      this.constraintsInput.Multiline = true;
+      this.constraintsInput.Name = "constraintsInput";
+      this.constraintsInput.ScrollBars = System.Windows.Forms.ScrollBars.Vertical;
+      this.constraintsInput.Size = new System.Drawing.Size(290, 405);
+      this.constraintsInput.TabIndex = 2;
+      this.constraintsInput.TextChanged += new System.EventHandler(this.constraintsInput_TextChanged);
+      // 
+      // parseBtn
+      // 
+      this.parseBtn.Dock = System.Windows.Forms.DockStyle.Bottom;
+      this.parseBtn.Location = new System.Drawing.Point(3, 590);
+      this.parseBtn.Name = "parseBtn";
+      this.parseBtn.Size = new System.Drawing.Size(290, 23);
+      this.parseBtn.TabIndex = 1;
+      this.parseBtn.Text = "Parse Constraints";
+      this.parseBtn.UseVisualStyleBackColor = true;
+      this.parseBtn.Click += new System.EventHandler(this.parseBtn_Click);
+      // 
+      // errorOutput
+      // 
+      this.errorOutput.MaximumSize = new Size(350, 0);
+      this.errorOutput.AutoSize = true;
+      this.errorOutput.ForeColor = Color.DarkRed;
+      this.errorOutput.Dock = System.Windows.Forms.DockStyle.Bottom;
+      this.errorOutput.Location = new System.Drawing.Point(3, 613);
+      this.errorOutput.Name = "errorOutput";
+      this.errorOutput.Size = new System.Drawing.Size(35, 13);
+      this.errorOutput.TabIndex = 3;
+      this.errorOutput.Text = "label2";
+      // 
+      // label1
+      // 
+      this.label1.AutoSize = true;
+      this.label1.Dock = System.Windows.Forms.DockStyle.Top;
+      this.label1.Location = new System.Drawing.Point(3, 16);
+      this.label1.Name = "label1";
+      this.label1.Size = new System.Drawing.Size(354, 169);
+      this.label1.TabIndex = 0;
+      this.label1.Text = "To define target variable constraints:" + Environment.NewLine +
+                         "1. Start the definition with target:" + Environment.NewLine +
+                         "2. Specify the target variable between '-characters" + Environment.NewLine +
+                         "3. Add the keyword in" + Environment.NewLine +
+                         "4. Specify the interval with [lowerbound .. upperbound]" + Environment.NewLine +
+                         "To define a derivation constraint: " + Environment.NewLine +
+                         "1. Start with d or \u2202" + Environment.NewLine +
+                         "2. Specify the target between '-characters" + Environment.NewLine +
+                         "3. Separate target and derivation variable with /" + Environment.NewLine +
+                         "4. Add derivation variable between '-characters'" + Environment.NewLine +
+                         "5. Follow the steps 3-4 from above";
+      // 
+      // intervalConstraintsView
+      // 
+      this.intervalConstraintsView.Dock = System.Windows.Forms.DockStyle.Fill;
+      this.intervalConstraintsView.Location = new System.Drawing.Point(0, 0);
+      this.intervalConstraintsView.Name = "intervalConstraintsView";
+      this.intervalConstraintsView.Size = new System.Drawing.Size(588, 20);
+      this.intervalConstraintsView.TabIndex = 2;
+      // 
+      // ProblemDataConstraintView
+      // 
+      this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.Controls.Add(this.splitContainer1);
+      this.Name = "ProblemDataConstraintView";
+      this.Size = new System.Drawing.Size(888, 629);
+      this.splitContainer1.Panel1.ResumeLayout(false);
+      this.splitContainer1.Panel2.ResumeLayout(false);
+      this.splitContainer1.Panel2.PerformLayout();
+      ((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).EndInit();
+      this.splitContainer1.ResumeLayout(false);
+      this.groupBox1.ResumeLayout(false);
+      this.groupBox1.PerformLayout();
+      this.ResumeLayout(false);
+
+    }
+    #endregion
+
+    private System.Windows.Forms.SplitContainer                             splitContainer1;
+    private System.Windows.Forms.GroupBox                                   groupBox1;
+    private System.Windows.Forms.Button                                     parseBtn;
+    private System.Windows.Forms.Label                                      label1;
+    private HeuristicLab.Core.Views.CheckedItemListView<IntervalConstraint> intervalConstraintsView;
+    private System.Windows.Forms.TextBox                                    constraintsInput;
+    private Label                                                           errorOutput;
+    }
+}
Index: /branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis.Views/3.4/ProblemDataConstraintView.cs
===================================================================
--- /branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis.Views/3.4/ProblemDataConstraintView.cs	(revision 17607)
+++ /branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis.Views/3.4/ProblemDataConstraintView.cs	(revision 17607)
@@ -0,0 +1,153 @@
+﻿#region License Information
+
+/* HeuristicLab
+ * Copyright (C) 2002-2019 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 System;
+using System.Collections.Generic;
+using System.Drawing;
+using HeuristicLab.Collections;
+using HeuristicLab.Core;
+using HeuristicLab.MainForm;
+using HeuristicLab.MainForm.WindowsForms;
+
+namespace HeuristicLab.Problems.DataAnalysis.Views {
+  [View("ParsedConstraint View")]
+  [Content(typeof(ProblemDataConstraint), true)]
+  public partial class ProblemDataConstraintView : AsynchronousContentView {
+    private readonly CheckedItemList<IntervalConstraint>
+      intervalConstraints = new CheckedItemList<IntervalConstraint>();
+
+    public new ProblemDataConstraint Content {
+      get => (ProblemDataConstraint) base.Content;
+      set => base.Content = value;
+    }
+
+    public ProblemDataConstraintView() {
+      InitializeComponent();
+      errorOutput.Text = "";
+    }
+
+    protected override void OnContentChanged() {
+      base.OnContentChanged();
+      UpdateControl();
+    }
+
+    protected override void RegisterContentEvents() {
+      base.RegisterContentEvents();
+      intervalConstraints.CheckedItemsChanged += constraint_CheckedItemChanged;
+      intervalConstraints.ItemsAdded          += constraints_Updated;
+      intervalConstraints.ItemsRemoved        += constraint_removed;
+      Content.Changed                         += Content_Changed;
+    }
+
+    protected override void DeregisterContentEvents() {
+      intervalConstraints.CheckedItemsChanged -= constraint_CheckedItemChanged;
+      intervalConstraints.ItemsAdded          -= constraints_Updated;
+      intervalConstraints.ItemsRemoved        -= constraint_removed;
+      Content.Changed                         -= Content_Changed;
+      base.DeregisterContentEvents();
+    }
+
+    protected override void SetEnabledStateOfControls() {
+      constraintsInput.Enabled = Content != null && !Locked && !ReadOnly;
+    }
+
+
+    private IEnumerable<IntervalConstraint> ParseConstraints(string input) {
+      return IntervalConstraintsParser.ParseInput(input, Content.ProblemData.TargetVariable,
+                                                  Content.ProblemData.AllowedInputVariables);
+    }
+
+    private void parseBtn_Click(object sender, EventArgs e) {
+      if (constraintsInput.Text != null) {
+        intervalConstraints.Clear();
+        try {
+          var parsedConstraints = ParseConstraints(constraintsInput.Text);
+          Content.Constraints = parsedConstraints;
+          Content.Input       = constraintsInput.Text;
+          Content.InfoText    = "Constraints successfully parsed.";
+          Content.InfoColor   = Color.DarkGreen;
+          //Catch the exception from the constraints parser and show it in the error dialog
+        }
+        catch (ArgumentException ex) {
+          Content.Constraints = new List<IntervalConstraint>();
+          Content.InfoText    = ex.Message.Replace("Parameter name", "@Line");
+          Content.InfoColor   = Color.DarkRed;
+        }
+      }
+      else {
+        errorOutput.Text = "No constraints were found!";
+      }
+    }
+
+    private void UpdateControl() {
+      if (Content == null) {
+        intervalConstraints.Clear();
+        intervalConstraintsView.Content = intervalConstraints;
+      }
+      else {
+        intervalConstraints.Clear();
+        constraintsInput.Text = Content.Input;
+        errorOutput.ForeColor = Content.InfoColor;
+        errorOutput.Text      = Content.InfoText;
+        foreach (var constraint in Content.Constraints) intervalConstraints.Add(constraint, constraint.Enabled);
+
+        intervalConstraintsView.Content = intervalConstraints;
+      }
+    }
+
+    private void constraint_Changed(object sender, EventArgs e) {
+      var constraint = (IntervalConstraint) sender;
+      intervalConstraints.SetItemCheckedState(constraint, constraint.Enabled);
+    }
+
+    private void constraints_Updated(object                                                           sender,
+                                     CollectionItemsChangedEventArgs<IndexedItem<IntervalConstraint>> e) {
+      foreach (var addedItem in e.Items) addedItem.Value.Changed += constraint_Changed;
+    }
+
+    private void constraint_removed(object sender, CollectionItemsChangedEventArgs<IndexedItem<IntervalConstraint>> e) {
+      foreach (var removedItem in e.Items) removedItem.Value.Changed -= constraint_Changed;
+    }
+
+    private void constraint_CheckedItemChanged(object                                                           sender,
+                                               CollectionItemsChangedEventArgs<IndexedItem<IntervalConstraint>> e) {
+      ICheckedItemList<IntervalConstraint> checkedItemList           = (ICheckedItemList<IntervalConstraint>) sender;
+      foreach (var indexedItem in e.Items) indexedItem.Value.Enabled = checkedItemList.ItemChecked(indexedItem.Value);
+    }
+
+    private void constraintsInput_TextChanged(object sender, EventArgs e) {
+      if (Content.Input != constraintsInput.Text) {
+        Content.Input     = constraintsInput.Text;
+        Content.InfoText  = "Unparsed changes! Press parse button to save changes.";
+        Content.InfoColor = Color.DarkOrange;
+      }
+      else {
+        errorOutput.Text = "";
+      }
+    }
+
+    private void Content_Changed(object sender, EventArgs e) {
+      UpdateControl();
+    }
+  }
+}
Index: /branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis/3.4/HeuristicLab.Problems.DataAnalysis-3.4.csproj
===================================================================
--- /branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis/3.4/HeuristicLab.Problems.DataAnalysis-3.4.csproj	(revision 17606)
+++ /branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis/3.4/HeuristicLab.Problems.DataAnalysis-3.4.csproj	(revision 17607)
@@ -190,4 +190,6 @@
     <Compile Include="Implementation\Interval\Interval.cs" />
     <Compile Include="Implementation\Interval\IntervalCollection.cs" />
+    <Compile Include="Implementation\Interval\IntervalConstraint.cs" />
+    <Compile Include="Implementation\Interval\IntervalConstraintsParser.cs" />
     <Compile Include="Implementation\Regression\ConfidenceBoundRegressionSolution.cs" />
     <Compile Include="Implementation\Regression\ConstantRegressionModel.cs" />
@@ -303,4 +305,5 @@
     <Compile Include="Interfaces\IDataAnalysisModel.cs" />
     <Compile Include="Interfaces\IDataAnalysisProblem.cs" />
+    <Compile Include="ProblemDataConstraint.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
Index: /branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/IntervalConstraint.cs
===================================================================
--- /branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/IntervalConstraint.cs	(revision 17607)
+++ /branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/IntervalConstraint.cs	(revision 17607)
@@ -0,0 +1,200 @@
+﻿#region License Information
+
+/* HeuristicLab
+ * Copyright (C) 2002-2019 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 System;
+using HEAL.Attic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Problems.DataAnalysis {
+  [StorableType("8109BE58-CCFB-4462-A2F4-EEE5DFADAFF7")]
+  [Item("Interval Constraint", "Constraint on intervals.")]
+  public sealed class IntervalConstraint : Item {
+    [Storable] private string expression;
+
+    public string Expression {
+      get => expression;
+      private set {
+        if (expression == value)
+          return;
+        expression = value;
+        OnChanged();
+        OnToStringChanged();
+      }
+    }
+
+    public string Definition => GetDefinitionString();
+
+    [Storable] private string variable;
+
+    public string Variable {
+      get => variable;
+      private set {
+        if (variable == value)
+          return;
+        variable = value;
+        UpdateExpression();
+        OnChanged();
+      }
+    }
+
+    [Storable] private string target;
+
+    public string Target {
+      get => target;
+      private set {
+        if (target == value)
+          return;
+        target = value;
+        UpdateExpression();
+        OnChanged();
+      }
+    }
+
+    public bool IsDerivative => NumberOfDerivations > 0;
+
+    [Storable] private int numberOfDerivations;
+
+    public int NumberOfDerivations {
+      get => numberOfDerivations;
+      set {
+        if (value < 0 || value > 3)
+          throw new ArgumentException("Number of derivation has to be between 0 - 3.");
+        if (numberOfDerivations == value)
+          return;
+        numberOfDerivations = value;
+        UpdateExpression();
+        OnChanged();
+      }
+    }
+
+    [Storable] private Interval interval;
+
+    public Interval Interval {
+      get => interval;
+      set {
+        if (interval == value)
+          return;
+        interval = value;
+        UpdateExpression();
+        OnChanged();
+      }
+    }
+
+    [Storable] private bool enabled;
+
+    public bool Enabled {
+      get => enabled;
+      set {
+        if (enabled == value)
+          return;
+        enabled = value;
+        OnChanged();
+      }
+    }
+
+    [StorableConstructor]
+    private IntervalConstraint(StorableConstructorFlag _) : base(_) { }
+
+    public IntervalConstraint(string   expression, string variable, string target, int numberOfDerivations,
+                              Interval interval,   bool   enabled) {
+      this.expression          = expression;
+      this.variable            = variable;
+      this.target              = target;
+      this.numberOfDerivations = numberOfDerivations;
+      this.interval            = interval;
+      this.enabled             = enabled;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new IntervalConstraint(this, cloner);
+    }
+
+    private IntervalConstraint(IntervalConstraint original, Cloner cloner)
+      : base(original, cloner) {
+      Expression          = original.Expression;
+      Variable            = original.Variable;
+      Target              = original.Target;
+      NumberOfDerivations = original.NumberOfDerivations;
+      Interval            = original.Interval;
+      Enabled             = original.Enabled;
+    }
+
+    public event EventHandler Changed;
+
+    private void OnChanged() {
+      var handlers = Changed;
+      if (handlers != null)
+        handlers(this, EventArgs.Empty);
+    }
+
+    private static string GetDerivationString(int derivation) {
+      switch (derivation) {
+        case 1:
+          return "";
+        case 2:
+          return "²";
+        case 3:
+          return "³";
+        default:
+          return "";
+      }
+    }
+
+    private void UpdateExpression() {
+      var expression = "";
+
+      if (!IsDerivative) {
+        expression = string.Format("Target:{0} in {1}{2} .. {3}{4}",
+                                   Variable,
+                                   "[",
+                                   Interval?.LowerBound,
+                                   Interval?.UpperBound,
+                                   "]");
+        Expression = expression;
+        return;
+      }
+
+      expression = string.Format("∂{6}{1}/∂{0}{6} in {2}{3} .. {4}{5}", 
+                                 Variable,
+                                 Target,
+                                 "[",
+                                 Interval?.LowerBound,
+                                 Interval?.UpperBound,
+                                 "]",
+                                 GetDerivationString(numberOfDerivations));
+      Expression = expression;
+    }
+
+    private string GetDefinitionString() {
+      if (!IsDerivative) return "Target " + Variable;
+
+      var definition =
+        $"∂{GetDerivationString(numberOfDerivations)}Target/∂{Variable}{GetDerivationString(numberOfDerivations)}";
+      return definition;
+    }
+
+    public override string ToString() {
+      return Expression;
+    }
+  }
+}
Index: /branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/IntervalConstraintsParser.cs
===================================================================
--- /branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/IntervalConstraintsParser.cs	(revision 17607)
+++ /branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/IntervalConstraintsParser.cs	(revision 17607)
@@ -0,0 +1,175 @@
+﻿#region License Information
+
+/* HeuristicLab
+ * Copyright (C) 2002-2019 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 System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text.RegularExpressions;
+
+namespace HeuristicLab.Problems.DataAnalysis {
+  public static class IntervalConstraintsParser {
+    public static IEnumerable<IntervalConstraint> ParseInput(string              inputText, string target,
+                                                             IEnumerable<string> variables) {
+      if (string.IsNullOrEmpty(inputText)) throw new ArgumentNullException("No input text has been provided.");
+      if (string.IsNullOrEmpty(target)) throw new ArgumentNullException("No target variable has been provided.");
+      if (variables == null) throw new ArgumentNullException("No variables have been provided.");
+      if (!variables.Any()) throw new ArgumentException("Variables are empty.");
+
+      var lines = inputText.Split(new[] {"\r\n", "\r", "\n"}, StringSplitOptions.None);
+      foreach (var line in lines) {
+        var trimmedLine = line.TrimStart();
+        //Check for target-variable constraint
+        if (trimmedLine.StartsWith("Target:")) {
+          var start            = "Target:".Length;
+          var end              = trimmedLine.Length;
+          var targetConstraint = trimmedLine.Substring(start, end - start);
+          var match = Regex.Match(targetConstraint,
+                                  @"(['](.*)[']|(.*[^\s]))\s*(\bin\b)\s*([\[])\s*(\S*)\s*(\.{2})\s*(\S*)\s*([\]])");
+          if (match.Success) {
+            if (match.Groups.Count != 10) throw new ArgumentException("The target-constraint is not complete.", line);
+
+            var targetVariable = match.Groups[1].Value.Trim();
+            if (match.Groups[1].Value.Trim().StartsWith("'") && match.Groups[1].Value.Trim().EndsWith("'"))
+              targetVariable = targetVariable.Substring(1, targetVariable.Length - 2);
+
+            if (targetVariable != target)
+              throw new
+                ArgumentException($"The target variable {targetVariable}  does not match the provided target {target}.",
+                                  line);
+
+            var lowerBound         = ParseIntervalBounds(match.Groups[6].Value);
+            var upperBound         = ParseIntervalBounds(match.Groups[8].Value);
+            var expression         = "Target:" + match.Groups[0].Value;
+            var parsedTarget       = match.Groups[1].Value.Trim();
+            var variable           = targetVariable;
+            var isEnabled          = true;
+            var numberOfDerivation = 0;
+            var interval           = new Interval(lowerBound, upperBound);
+
+            var constraint =
+              new IntervalConstraint(expression, variable, parsedTarget, numberOfDerivation, interval, isEnabled);
+
+            yield return constraint;
+          }
+          else {
+            throw new ArgumentException("The inserted target constraint is not valid.", line);
+          }
+
+          //Check for derivation
+        }
+        else if (trimmedLine.StartsWith("d") || trimmedLine.StartsWith("\u2202")) {
+          var match = Regex.Match(trimmedLine,
+                                  @"([d∂])([²³]?)\s*(['](.*)[']|(.*[^\s]))\s*(\/)\s*([d∂])\s*(['](.*)[']|(.*[^\s²³]))\s*([²³]?)\s*\bin\b\s*([\[])\s*(\S*)\s*(\.{2})\s*(\S*)\s*([\]])");
+
+          if (match.Success) {
+            if (match.Groups.Count != 17)
+              throw new ArgumentException("The given derivation-constraint is not complete.", line);
+
+            var derivationTarget   = match.Groups[3].Value.Trim();
+            var derivationVariable = match.Groups[8].Value.Trim();
+
+            if (match.Groups[3].Value.Trim().StartsWith("'") && match.Groups[3].Value.Trim().EndsWith("'"))
+              derivationTarget = derivationTarget.Substring(1, derivationTarget.Length - 2);
+
+            if (match.Groups[8].Value.Trim().StartsWith("'") && match.Groups[8].Value.Trim().EndsWith("'"))
+              derivationVariable = derivationVariable.Substring(1, derivationVariable.Length - 2);
+
+            if (derivationTarget != target)
+              throw new
+                ArgumentException($"The target variable {derivationTarget}  does not match the provided target {target}.",
+                                  line);
+
+            if (variables.All(v => v != derivationVariable))
+              throw new ArgumentException($"The given variable {derivationVariable} does not exist in the dataset.",
+                                          line);
+
+            if (match.Groups[2].Value.Trim() != "" || match.Groups[11].Value.Trim() != "") {
+              if (match.Groups[2].Value.Trim() == "" || match.Groups[11].Value.Trim() == "")
+                throw new ArgumentException("Number of derivation has to be written on both sides.", line);
+              if (match.Groups[2].Value.Trim() != match.Groups[11].Value.Trim())
+                throw new ArgumentException("Derivation number is not equal on both sides.", line);
+            }
+
+            var lowerBound         = ParseIntervalBounds(match.Groups[13].Value);
+            var upperBound         = ParseIntervalBounds(match.Groups[15].Value);
+            var expression         = match.Groups[0].Value;
+            var parsedTarget       = derivationTarget;
+            var isEnabled          = true;
+            var variable           = derivationVariable;
+            var numberOfDerivation = ParseDerivationCount(match.Groups[2].Value.Trim());
+            var interval           = new Interval(lowerBound, upperBound);
+
+            var constraint =
+              new IntervalConstraint(expression, variable, parsedTarget, numberOfDerivation, interval, isEnabled);
+
+            yield return constraint;
+          }
+          else {
+            throw new ArgumentException("The inserted derivation constraint is not valid.", line);
+          }
+
+          //Check for comment
+        }
+        else if (trimmedLine.StartsWith("#") || trimmedLine == "") {
+          //If it is a comment just continue without saving anything
+        }
+        else {
+          throw new
+            ArgumentException("Error at your constraints definition constraints have to start with (Target: | d | \u2202 | #)",
+                              line);
+        }
+      }
+    }
+
+    private static double ParseIntervalBounds(string input) {
+      input = input.ToLower();
+      switch (input) {
+        case "+inf.":
+        case "inf.":
+          return double.PositiveInfinity;
+        case "-inf.":
+          return double.NegativeInfinity;
+        default: {
+          if (double.TryParse(input, NumberStyles.Any, CultureInfo.InvariantCulture, out var value))
+            return value;
+          throw new ArgumentException("The given boundary is not a double value!");
+        }
+      }
+    }
+
+    private static int ParseDerivationCount(string input) {
+      switch (input) {
+        case "":
+          return 1;
+        case "²":
+          return 2;
+        case "³":
+          return 3;
+        default:
+          int.TryParse(input, out var value);
+          return value;
+      }
+    }
+  }
+}
Index: /branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionProblemData.cs
===================================================================
--- /branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionProblemData.cs	(revision 17606)
+++ /branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionProblemData.cs	(revision 17607)
@@ -94,4 +94,5 @@
       problemData.Parameters.Add(new ConstrainedValueParameter<StringValue>(TargetVariableParameterName, new ItemSet<StringValue>()));
       problemData.Parameters.Add(new FixedValueParameter<IntervalCollection>(VariableRangesParameterName, "", new IntervalCollection()));
+      problemData.Parameters.Add(new FixedValueParameter<ProblemDataConstraint>(IntervalConstraintsParameterName, "", new ProblemDataConstraint(problemData)));
       emptyProblemData = problemData;
     }
@@ -107,4 +108,9 @@
       get => VariableRangesParameter.Value;
     }
+
+    public IFixedValueParameter<ProblemDataConstraint> IntervalConstraintsParameter =>
+      (IFixedValueParameter<ProblemDataConstraint>) Parameters[IntervalConstraintsParameterName];
+
+    public ProblemDataConstraint IntervalConstraints => IntervalConstraintsParameter.Value;
 
 
@@ -140,4 +146,8 @@
         Parameters.Add(new FixedValueParameter<IntervalCollection>(VariableRangesParameterName, intervalCollection));
       }
+
+      if (!Parameters.ContainsKey(IntervalConstraintsParameterName)) {
+        Parameters.Add(new FixedValueParameter<ProblemDataConstraint>(IntervalConstraintsParameterName, new ProblemDataConstraint(this)));
+      }
       RegisterParameterEvents();
     }
@@ -169,4 +179,5 @@
       var intervalCollection = CalculateDatasetIntervals(this.Dataset);
       Parameters.Add(new FixedValueParameter<IntervalCollection>(VariableRangesParameterName, intervalCollection));
+      Parameters.Add(new FixedValueParameter<ProblemDataConstraint>(IntervalConstraintsParameterName, new ProblemDataConstraint(this)));
       RegisterParameterEvents();
     }
Index: /branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/Regression/IRegressionProblemData.cs
===================================================================
--- /branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/Regression/IRegressionProblemData.cs	(revision 17606)
+++ /branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/Regression/IRegressionProblemData.cs	(revision 17607)
@@ -1,3 +1,4 @@
 ﻿#region License Information
+
 /* HeuristicLab
  * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
@@ -18,4 +19,5 @@
  * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
  */
+
 #endregion
 
@@ -28,9 +30,10 @@
     string TargetVariable { get; set; }
 
-    IntervalCollection VariableRanges { get;}
+    IntervalCollection    VariableRanges      { get; }
+    ProblemDataConstraint IntervalConstraints { get; }
 
-    IEnumerable<double> TargetVariableValues { get; }
+    IEnumerable<double> TargetVariableValues         { get; }
     IEnumerable<double> TargetVariableTrainingValues { get; }
-    IEnumerable<double> TargetVariableTestValues { get; }
+    IEnumerable<double> TargetVariableTestValues     { get; }
   }
 }
Index: /branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis/3.4/ProblemDataConstraint.cs
===================================================================
--- /branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis/3.4/ProblemDataConstraint.cs	(revision 17607)
+++ /branches/3073_IA_constraint_splitting/HeuristicLab.Problems.DataAnalysis/3.4/ProblemDataConstraint.cs	(revision 17607)
@@ -0,0 +1,135 @@
+﻿#region License Information
+
+/* HeuristicLab
+ * Copyright (C) 2002-2019 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 System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using HEAL.Attic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Problems.DataAnalysis {
+  [StorableType("A56BFB05-8F11-4766-9FBF-20C7010F1CA3")]
+  [Item("ProblemDataConstraints", "Represents constraints associated with a problem data.")]
+  public class ProblemDataConstraint : Item {
+    private static readonly string exampleInput = "# Example for a target variable constraint:"     +
+                                                  Environment.NewLine                               +
+                                                  "Target:'y' in [0 .. 100]"                        +
+                                                  Environment.NewLine                               +
+                                                  Environment.NewLine                               +
+                                                  "# Example for constraints on model parameters: " +
+                                                  Environment.NewLine                               +
+                                                  "d'y'/d'x' in [0 .. 10]"                          +
+                                                  Environment.NewLine                               +
+                                                  "∂²'y'/∂'x'² in [-1 .. inf.]";
+
+    [Storable] private string input;
+
+    public string Input {
+      get => input;
+      set {
+        if (input == value) return;
+        input = value;
+        OnChanged();
+      }
+    }
+
+    [Storable] private string infoText;
+
+    public string InfoText {
+      get => infoText;
+      set {
+        if (infoText == value) return;
+        infoText = value;
+        OnChanged();
+      }
+    }
+
+    [Storable] private Color infoColor;
+
+    public Color InfoColor {
+      get => infoColor;
+      set {
+        if (infoColor == value) return;
+        infoColor = value;
+        OnChanged();
+      }
+    }
+
+    [Storable] private IEnumerable<IntervalConstraint> constraints;
+
+    public IEnumerable<IntervalConstraint> Constraints {
+      get => constraints;
+      set {
+        if (constraints == value) return;
+        constraints = value.ToList();
+        OnChanged();
+      }
+    }
+
+    public IEnumerable<IntervalConstraint> EnabledConstraints => Constraints.Where(c => c.Enabled);
+
+
+    [Storable] public IRegressionProblemData ProblemData { get; }
+
+    [StorableConstructor]
+    protected ProblemDataConstraint(StorableConstructorFlag _) : base(_) { }
+
+    protected ProblemDataConstraint(ProblemDataConstraint original, Cloner cloner)
+      : base(original, cloner) {
+      Input       = original.Input;
+      InfoText    = original.InfoText;
+      infoColor   = original.InfoColor;
+      constraints = original.Constraints.Select(cloner.Clone).ToList();
+      ProblemData = cloner.Clone(original.ProblemData);
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ProblemDataConstraint(this, cloner);
+    }
+
+    public ProblemDataConstraint() {
+      Input       = exampleInput;
+      InfoText    = "";
+      InfoColor   = Color.DarkOrange;
+      constraints = new List<IntervalConstraint>();
+      ProblemData = null;
+    }
+
+    public ProblemDataConstraint(IRegressionProblemData problemData) {
+      Input       = exampleInput;
+      InfoText    = infoText;
+      InfoColor   = InfoColor;
+      constraints = new List<IntervalConstraint>();
+      ProblemData = problemData;
+    }
+
+    public event EventHandler Changed;
+
+    protected virtual void OnChanged() {
+      var handlers = Changed;
+      if (handlers != null)
+        handlers(this, EventArgs.Empty);
+    }
+  }
+}
