Index: branches/2956_apriori_knowledge/HeuristicLab 3.3.sln
===================================================================
--- branches/2956_apriori_knowledge/HeuristicLab 3.3.sln	(revision 16295)
+++ branches/2956_apriori_knowledge/HeuristicLab 3.3.sln	(revision 16303)
@@ -2,5 +2,5 @@
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 15
-VisualStudioVersion = 15.0.26730.16
+VisualStudioVersion = 15.0.26403.7
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{96396439-A764-4022-A8D2-BE021449B8D1}"
@@ -462,4 +462,6 @@
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Algorithms.MOCMAEvolutionStrategy-3.3", "HeuristicLab.Algorithms.MOCMAEvolutionStrategy\3.3\HeuristicLab.Algorithms.MOCMAEvolutionStrategy-3.3.csproj", "{0E2E224F-E9B2-41F3-B510-09183EEBA2AF}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration", "HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration\3.4\HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration-3.4.csproj", "{5E8B5347-4281-4D89-92E5-8D81E297BBCA}"
 EndProject
 Global
@@ -2249,4 +2251,16 @@
 		{0E2E224F-E9B2-41F3-B510-09183EEBA2AF}.Release|x86.ActiveCfg = Release|x86
 		{0E2E224F-E9B2-41F3-B510-09183EEBA2AF}.Release|x86.Build.0 = Release|x86
+		{5E8B5347-4281-4D89-92E5-8D81E297BBCA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{5E8B5347-4281-4D89-92E5-8D81E297BBCA}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{5E8B5347-4281-4D89-92E5-8D81E297BBCA}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{5E8B5347-4281-4D89-92E5-8D81E297BBCA}.Debug|x64.Build.0 = Debug|Any CPU
+		{5E8B5347-4281-4D89-92E5-8D81E297BBCA}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{5E8B5347-4281-4D89-92E5-8D81E297BBCA}.Debug|x86.Build.0 = Debug|Any CPU
+		{5E8B5347-4281-4D89-92E5-8D81E297BBCA}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{5E8B5347-4281-4D89-92E5-8D81E297BBCA}.Release|Any CPU.Build.0 = Release|Any CPU
+		{5E8B5347-4281-4D89-92E5-8D81E297BBCA}.Release|x64.ActiveCfg = Release|Any CPU
+		{5E8B5347-4281-4D89-92E5-8D81E297BBCA}.Release|x64.Build.0 = Release|Any CPU
+		{5E8B5347-4281-4D89-92E5-8D81E297BBCA}.Release|x86.ActiveCfg = Release|Any CPU
+		{5E8B5347-4281-4D89-92E5-8D81E297BBCA}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
Index: branches/2956_apriori_knowledge/HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration/3.4/HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration-3.4.csproj
===================================================================
--- branches/2956_apriori_knowledge/HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration/3.4/HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration-3.4.csproj	(revision 16303)
+++ branches/2956_apriori_knowledge/HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration/3.4/HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration-3.4.csproj	(revision 16303)
@@ -0,0 +1,106 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{5E8B5347-4281-4D89-92E5-8D81E297BBCA}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration</RootNamespace>
+    <AssemblyName>HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration-3.4</AssemblyName>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <TargetFrameworkProfile />
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>..\..\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup>
+    <SignAssembly>true</SignAssembly>
+  </PropertyGroup>
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>HeuristicLab.snk</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="HeuristicLab.Common-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\trunk\bin\HeuristicLab.Common-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Core-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\trunk\bin\HeuristicLab.Core-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Persistence-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\trunk\bin\HeuristicLab.Persistence-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.PluginInfrastructure-3.3">
+      <HintPath>..\..\..\trunk\bin\HeuristicLab.PluginInfrastructure-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Problems.DataAnalysis.Symbolic-3.4, Version=3.4.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\trunk\bin\HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Util\FormulationParser.cs" />
+    <None Include="Plugin.cs.frame" />
+    <Compile Include="Interpreter\SymbolicDataAnalysisIntervalArithmeticInterpreter.cs" />
+    <Compile Include="IntervalArithmetic\Interval.cs" />
+    <Compile Include="Plugin.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="HeuristicLab.snk" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Collections\3.3\HeuristicLab.Collections-3.3.csproj">
+      <Project>{958B43BC-CC5C-4FA2-8628-2B3B01D890B6}</Project>
+      <Name>HeuristicLab.Collections-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Data\3.3\HeuristicLab.Data-3.3.csproj">
+      <Project>{BBAB9DF5-5EF3-4BA8-ADE9-B36E82114937}</Project>
+      <Name>HeuristicLab.Data-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Encodings.SymbolicExpressionTreeEncoding\3.4\HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4.csproj">
+      <Project>{06D4A186-9319-48A0-BADE-A2058D462EEA}</Project>
+      <Name>HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Problems.DataAnalysis\3.4\HeuristicLab.Problems.DataAnalysis-3.4.csproj">
+      <Project>{DF87C13E-A889-46FF-8153-66DCAA8C5674}</Project>
+      <Name>HeuristicLab.Problems.DataAnalysis-3.4</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <PropertyGroup>
+    <PreBuildEvent>set Path=%25Path%25;$(ProjectDir);$(SolutionDir)
+set ProjectDir=$(ProjectDir)
+set SolutionDir=$(SolutionDir)
+set Outdir=$(Outdir)
+
+call PreBuildEvent.cmd</PreBuildEvent>
+  </PropertyGroup>
+</Project>
Index: branches/2956_apriori_knowledge/HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration/3.4/Interpreter/SymbolicDataAnalysisIntervalArithmeticInterpreter.cs
===================================================================
--- branches/2956_apriori_knowledge/HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration/3.4/Interpreter/SymbolicDataAnalysisIntervalArithmeticInterpreter.cs	(revision 16303)
+++ branches/2956_apriori_knowledge/HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration/3.4/Interpreter/SymbolicDataAnalysisIntervalArithmeticInterpreter.cs	(revision 16303)
@@ -0,0 +1,221 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration.IntervalArithmetic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis;
+using HeuristicLab.Problems.DataAnalysis.Symbolic;
+
+namespace HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration.Interpreter {
+  [StorableClass]
+  [Item("SymbolicDataAnalysisIntervalArithmeticInterpreter", "Interpreter for interval arithmetic within symbolic regression.")]
+  public class SymbolicDataAnalysisIntervalArithmeticInterpreter : ParameterizedNamedItem{
+    private const string EvaluatedSolutionsParameterName = "EvaluatedSolutions";
+    public IFixedValueParameter<IntValue> EvaluatedSolutionsParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[EvaluatedSolutionsParameterName]; }
+    }
+
+    public int EvaluatedSolutions {
+      get { return EvaluatedSolutionsParameter.Value.Value; }
+      set { EvaluatedSolutionsParameter.Value.Value = value; }
+    }
+
+    public void ClearState() { }
+
+    protected SymbolicDataAnalysisIntervalArithmeticInterpreter(bool deserializing) : base(deserializing) { }
+
+    protected SymbolicDataAnalysisIntervalArithmeticInterpreter(SymbolicDataAnalysisIntervalArithmeticInterpreter original,
+        Cloner cloner)
+        : base(original, cloner) { }
+
+    public SymbolicDataAnalysisIntervalArithmeticInterpreter()
+        : base("SymbolicDataAnalysisIntervalArithmeticInterpreter", "Interpreter for interval arithmetic within symbolic regression.") { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SymbolicDataAnalysisIntervalArithmeticInterpreter(this, cloner);
+    }
+
+    private readonly object syncRoot = new object();
+
+    private static InterpreterState PrepareInterpreterState(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows, Dictionary<string, Interval> customIntervals = null) {
+      Instruction[] code = SymbolicExpressionTreeCompiler.Compile(tree, OpCodes.MapSymbolToOpCode);
+      int necessaryArgStackSize = 0;
+      
+      foreach(Instruction instr in code) {
+        if (instr.opCode == OpCodes.Variable) {
+          var variableTreeNode = (VariableTreeNode)instr.dynamicNode;
+          IList<double> values = new List<double>();
+
+          if (customIntervals != null && customIntervals.ContainsKey(variableTreeNode.VariableName)) {
+            instr.data = customIntervals[variableTreeNode.VariableName];
+          } else {
+            foreach (var rowEnum in rows) {
+              values.Add(dataset.GetReadOnlyDoubleValues(variableTreeNode.VariableName)[rowEnum]);
+            }
+            instr.data = new Interval(values.Min(), values.Max());
+          }
+        }
+      }
+
+      return new InterpreterState(code, necessaryArgStackSize);
+    }
+
+    //private static InterpreterState PrepareInterpreterState(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows, Dictionary<string, Interval> customIntervals = null) {
+    //  Instruction[] code = SymbolicExpressionTreeCompiler.Compile(tree, OpCodes.MapSymbolToOpCode);
+    //  int necessaryArgStackSize = 0;
+    //  foreach (Instruction instr in code) {
+    //    if (instr.opCode == OpCodes.Variable) {
+    //      var variableTreeNode = (VariableTreeNode)instr.dynamicNode;
+    //      IList<double> values = new List<double>();
+
+    //      if (customIntervals != null && customIntervals.ContainsKey(variableTreeNode.VariableName)) {
+    //        instr.data = customIntervals[variableTreeNode.VariableName];
+    //      } else {
+    //        foreach (var rowEnum in rows) {
+    //          values.Add(dataset.GetReadOnlyDoubleValues(variableTreeNode.VariableName)[rowEnum]);
+    //        }
+    //        instr.data = new Interval(values.Min(), values.Max());
+    //      }
+    //      //instr.data = dataset.GetReadOnlyDoubleValues(variableTreeNode.VariableName);
+    //    } else if (instr.opCode == OpCodes.FactorVariable) {
+    //      var factorTreeNode = instr.dynamicNode as FactorVariableTreeNode;
+    //      instr.data = dataset.GetReadOnlyStringValues(factorTreeNode.VariableName);
+    //    } else if (instr.opCode == OpCodes.BinaryFactorVariable) {
+    //      var factorTreeNode = instr.dynamicNode as BinaryFactorVariableTreeNode;
+    //      instr.data = dataset.GetReadOnlyStringValues(factorTreeNode.VariableName);
+    //    } else if (instr.opCode == OpCodes.LagVariable) {
+    //      var laggedVariableTreeNode = (LaggedVariableTreeNode)instr.dynamicNode;
+    //      instr.data = dataset.GetReadOnlyDoubleValues(laggedVariableTreeNode.VariableName);
+    //    } else if (instr.opCode == OpCodes.VariableCondition) {
+    //      var variableConditionTreeNode = (VariableConditionTreeNode)instr.dynamicNode;
+    //      instr.data = dataset.GetReadOnlyDoubleValues(variableConditionTreeNode.VariableName);
+    //    } else if (instr.opCode == OpCodes.Call) {
+    //      necessaryArgStackSize += instr.nArguments + 1;
+    //    }
+    //  }
+    //  return new InterpreterState(code, necessaryArgStackSize);
+    //}
+
+    private Interval Evaluate(InterpreterState state, Dictionary<ISymbolicExpressionTreeNode, Interval> intervals) {
+      Instruction currentInstr = state.NextInstruction();
+      switch (currentInstr.opCode) {
+        //Elementary arithmetic rules
+        case OpCodes.Add: {
+            var s = Evaluate(state, intervals);
+            for (int i = 1; i < currentInstr.nArguments; i++) {
+              s = Interval.Add(s, Evaluate(state, intervals));
+            }
+            intervals.Add(currentInstr.dynamicNode, s);
+            return s;
+          }
+        case OpCodes.Sub: {
+            var s = Evaluate(state, intervals);
+            for (int i = 1; i < currentInstr.nArguments; i++) {
+              s = Interval.Subtract(s, Evaluate(state, intervals));
+            }
+            intervals.Add(currentInstr.dynamicNode, s);
+            return s;
+          }
+        case OpCodes.Mul: {
+            var s = Evaluate(state, intervals);
+            for (int i = 1; i < currentInstr.nArguments; i++) {
+              s = Interval.Multiply(s, Evaluate(state, intervals));
+            }
+            intervals.Add(currentInstr.dynamicNode, s);
+            return s;
+          }
+        case OpCodes.Div: {
+            var s = Evaluate(state, intervals);
+            for (int i = 1; i < currentInstr.nArguments; i++) {
+              s = Interval.Divide(s, Evaluate(state, intervals));
+            }
+            intervals.Add(currentInstr.dynamicNode, s);
+            return s;
+          }
+        //Trigonometric functions
+        case OpCodes.Sin: {
+            var s = Interval.Sine(Evaluate(state, intervals));
+            intervals.Add(currentInstr.dynamicNode, s);
+            return s;
+          }
+        case OpCodes.Cos: {
+            var s = Interval.Cosine(Evaluate(state, intervals));
+            intervals.Add(currentInstr.dynamicNode, s);
+            return s;
+          }
+        case OpCodes.Tan: {
+            var s = Interval.Tangens(Evaluate(state, intervals));
+            intervals.Add(currentInstr.dynamicNode, s);
+            return s;
+          }
+        //Exponential functions
+        case OpCodes.Log: {
+            var s = Interval.Logarithm(Evaluate(state, intervals));
+            intervals.Add(currentInstr.dynamicNode, s);
+            return s;
+          }
+        case OpCodes.Exp: {
+            var s = Interval.Exponential(Evaluate(state, intervals));
+            intervals.Add(currentInstr.dynamicNode, s);
+            return s;
+          }
+        case OpCodes.Power: {
+            var s = Evaluate(state, intervals);
+            for (int i = 1; i < currentInstr.nArguments; i++) {
+              s = Interval.Power(s, Evaluate(state, intervals));
+            }
+            intervals.Add(currentInstr.dynamicNode, s);
+            return s;
+          }
+        case OpCodes.Root: {
+            var s = Evaluate(state, intervals);
+            for (int i = 1; i < currentInstr.nArguments; i++) {
+              s = Interval.Root(s, Evaluate(state, intervals));
+            }
+            intervals.Add(currentInstr.dynamicNode, s);
+            return s;
+          }
+        //Variables, Constants, ...
+        case OpCodes.Variable: {
+            intervals.Add(currentInstr.dynamicNode, (Interval)currentInstr.data);
+            return (Interval)currentInstr.data;
+          }
+        case OpCodes.Constant: {
+            var constTreeNode = (ConstantTreeNode)currentInstr.dynamicNode;
+            var inter = new Interval(constTreeNode.Value, constTreeNode.Value);
+            intervals.Add(currentInstr.dynamicNode, inter);
+            return inter;
+          }
+        default:
+          throw new NotSupportedException();
+      }
+    }
+
+    public void InitializeState() {
+      EvaluatedSolutions = 0;
+    }
+
+    //public InterpreterState GetInstructions(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows, Dictionary<string, Interval> customIntervals = null) {
+    //  var state = PrepareInterpreterState(tree, dataset, rows, customIntervals);
+    //  var x = Evaluate(dataset, state);
+    //  state.Reset();
+      
+    //  return state;
+    //}
+
+   // public Interval GetSymbolicExressionTreeInterval(tree,variableIntervals)
+    //public Interval GetSymbolicExressionTreeInterval(tree,Dataset,intervals = null)
+    public Interval GetSymbolicExressionTreeIntervals(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows, 
+      out Dictionary<ISymbolicExpressionTreeNode, Interval> intervals) {
+      intervals = new Dictionary<ISymbolicExpressionTreeNode, Interval>();
+      var state = PrepareInterpreterState(tree, dataset, rows);
+      var x = Evaluate(state, intervals);
+      
+      return x;
+    }
+  }
+}
Index: branches/2956_apriori_knowledge/HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration/3.4/IntervalArithmetic/Interval.cs
===================================================================
--- branches/2956_apriori_knowledge/HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration/3.4/IntervalArithmetic/Interval.cs	(revision 16303)
+++ branches/2956_apriori_knowledge/HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration/3.4/IntervalArithmetic/Interval.cs	(revision 16303)
@@ -0,0 +1,187 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration.IntervalArithmetic {
+  public class Interval : IEquatable<Interval> {
+    private double lowerBound;
+    public double LowerBound {
+      get { return lowerBound; }
+      set { lowerBound = value; }
+    }
+    private double upperBound;
+    public double UpperBound {
+      get { return upperBound; }
+      set { lowerBound = value; }
+    }
+
+    public Interval() { }
+
+    public Interval(double lowerBound, double upperBound) {
+      if (lowerBound > upperBound)
+        throw new ArgumentException("LowerBound must be smaller than UpperBound.");
+
+      this.lowerBound = lowerBound;
+      this.upperBound = upperBound;
+    }
+
+    public bool Contains(double value) {
+      return lowerBound <= value && value <= upperBound;
+    }
+
+    public override string ToString() {
+      return "Interval: [" + lowerBound + ", " + upperBound + "]";
+    }
+
+    public bool IsInfiniteOrUndefined {
+      get {
+        return double.IsInfinity(LowerBound) || double.IsInfinity(UpperBound) ||
+                double.IsNaN(LowerBound) || double.IsNaN(UpperBound);
+      }
+    }
+
+    #region Equals, GetHashCode, == , !=
+    public bool Equals(Interval other) {
+      if (other == null)
+        return false;
+
+      return this.upperBound.IsAlmost(other.upperBound) && this.lowerBound.IsAlmost(other.lowerBound);
+    }
+
+    public override bool Equals(object obj) {
+      return Equals(obj as Interval);
+    }
+
+    public override int GetHashCode() {
+      return lowerBound.GetHashCode() ^ upperBound.GetHashCode();
+    }
+
+    public static bool operator ==(Interval interval1, Interval interval2) {
+      if (ReferenceEquals(interval1, null)) return ReferenceEquals(interval2, null);
+      return interval1.Equals(interval2);
+    }
+    public static bool operator !=(Interval interval1, Interval interval2) {
+      return !(interval1 == interval2);
+    }
+    #endregion
+
+    #region operations
+
+    // [x1,x2] + [y1,y2] = [x1 + y1,x2 + y2]
+    public static Interval Add(Interval a, Interval b) {
+      return new Interval(a.lowerBound + b.lowerBound, a.upperBound + b.upperBound);
+    }
+
+    // [x1,x2] − [y1,y2] = [x1 − y2,x2 − y1]
+    public static Interval Subtract(Interval a, Interval b) {
+      return new Interval(a.lowerBound - b.upperBound, a.upperBound - b.lowerBound);
+    }
+
+    // [x1,x2] * [y1,y2] = [min(x1*y1,x1*y2,x2*y1,x2*y2),max(x1*y1,x1*y2,x2*y1,x2*y2)]
+    public static Interval Multiply(Interval a, Interval b) {
+      double v1 = a.lowerBound * b.lowerBound;
+      double v2 = a.lowerBound * b.upperBound;
+      double v3 = a.upperBound * b.lowerBound;
+      double v4 = a.upperBound * b.upperBound;
+
+      double min = Math.Min(Math.Min(v1, v2), Math.Min(v3, v4));
+      double max = Math.Max(Math.Min(v1, v2), Math.Max(v3, v4));
+      return new Interval(min, max);
+    }
+
+    //mkommend: Divisiont by intervals containing 0 is implemented as defined in
+    //http://en.wikipedia.org/wiki/Interval_arithmetic
+    public static Interval Divide(Interval a, Interval b) {
+      if (b.Contains(0.0)) {
+        if (b.lowerBound.IsAlmost(0.0)) return Interval.Multiply(a, new Interval(1.0 / b.upperBound, double.PositiveInfinity));
+        else if (b.upperBound.IsAlmost(0.0)) return Interval.Multiply(a, new Interval(double.NegativeInfinity, 1.0 / b.lowerBound));
+        else return new Interval(double.NegativeInfinity, double.PositiveInfinity);
+      }
+      return Interval.Multiply(a, new Interval(1.0 / b.upperBound, 1.0 / b.lowerBound));
+    }
+
+    public static Interval Sine(Interval a) {
+      if (Math.Abs(a.upperBound - a.lowerBound) >= Math.PI * 2) return new Interval(-1, 1);
+
+      //divide the interval by PI/2 so that the optima lie at x element of N (0,1,2,3,4,...)
+      double Pihalf = Math.PI / 2;
+      Interval scaled = Interval.Divide(a, new Interval(Pihalf, Pihalf));
+      //move to positive scale
+      if (scaled.lowerBound < 0) {
+        int periodsToMove = Math.Abs((int)scaled.lowerBound / 4) + 1;
+        scaled = Interval.Add(scaled, new Interval(periodsToMove * 4, periodsToMove * 4));
+      }
+
+      double scaledLowerBound = scaled.lowerBound % 4.0;
+      double scaledUpperBound = scaled.upperBound % 4.0;
+      if (scaledUpperBound < scaledLowerBound) scaledUpperBound += 4.0;
+      List<double> sinValues = new List<double>();
+      sinValues.Add(Math.Sin(scaledLowerBound * Pihalf));
+      sinValues.Add(Math.Sin(scaledUpperBound * Pihalf));
+
+      int startValue = (int)Math.Ceiling(scaledLowerBound);
+      while (startValue < scaledUpperBound) {
+        sinValues.Add(Math.Sin(startValue * Pihalf));
+        startValue += 1;
+      }
+
+      return new Interval(sinValues.Min(), sinValues.Max());
+    }
+    public static Interval Cosine(Interval a) {
+      return Interval.Sine(Interval.Subtract(a, new Interval(Math.PI / 2, Math.PI / 2)));
+    }
+    public static Interval Tangens(Interval a) {
+      return Interval.Divide(Interval.Sine(a), Interval.Cosine(a));
+    }
+
+    public static Interval Logarithm(Interval a) {
+      return new Interval(Math.Log(a.lowerBound), Math.Log(a.upperBound));
+    }
+    public static Interval Exponential(Interval a) {
+      return new Interval(Math.Exp(a.lowerBound), Math.Exp(a.upperBound));
+    }
+
+    public static Interval Power(Interval a, Interval b) {
+      if (a.Contains(0.0) && b.lowerBound < 0) return new Interval(double.NaN, double.NaN);
+
+      int bLower = (int)Math.Round(b.lowerBound);
+      int bUpper = (int)Math.Round(b.upperBound);
+
+      List<double> powerValues = new List<double>();
+      powerValues.Add(Math.Pow(a.upperBound, bUpper));
+      powerValues.Add(Math.Pow(a.upperBound, bUpper - 1));
+      powerValues.Add(Math.Pow(a.upperBound, bLower));
+      powerValues.Add(Math.Pow(a.upperBound, bLower + 1));
+
+      powerValues.Add(Math.Pow(a.lowerBound, bUpper));
+      powerValues.Add(Math.Pow(a.lowerBound, bUpper - 1));
+      powerValues.Add(Math.Pow(a.lowerBound, bLower));
+      powerValues.Add(Math.Pow(a.lowerBound, bLower + 1));
+
+      return new Interval(powerValues.Min(), powerValues.Max());
+    }
+
+
+    public static Interval Root(Interval a, Interval b) {
+      int lower = (int)Math.Round(b.lowerBound);
+      int higher = (int)Math.Round(b.upperBound);
+
+      return new Interval(Math.Pow(a.lowerBound, 1.0 / higher), Math.Pow(a.upperBound, 1.0 / lower));
+    }
+
+    public static Interval Average(IEnumerable<Interval> intervals) {
+      if (intervals == null || !intervals.Any()) throw new ArgumentException();
+
+      int count = intervals.Count();
+      Interval result = intervals.First();
+      foreach (Interval i in intervals.Skip(1))
+        result = Interval.Add(result, i);
+
+      return new Interval(result.lowerBound / count, result.upperBound / count);
+    }
+    #endregion
+  }
+}
Index: branches/2956_apriori_knowledge/HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration/3.4/Plugin.cs
===================================================================
--- branches/2956_apriori_knowledge/HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration/3.4/Plugin.cs	(revision 16303)
+++ branches/2956_apriori_knowledge/HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration/3.4/Plugin.cs	(revision 16303)
@@ -0,0 +1,35 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.PluginInfrastructure;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace HeuristicLab.Algorithms.DataAnalysis.IntervalArithmetic
+{
+    [Plugin("HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntergration", "3.4.0.0")]
+    [PluginFile("HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration-3.4.dll", PluginFileType.Assembly)]
+    public class Plugin : PluginBase{
+    }
+}
Index: branches/2956_apriori_knowledge/HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration/3.4/Plugin.cs.frame
===================================================================
--- branches/2956_apriori_knowledge/HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration/3.4/Plugin.cs.frame	(revision 16303)
+++ branches/2956_apriori_knowledge/HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration/3.4/Plugin.cs.frame	(revision 16303)
@@ -0,0 +1,35 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.PluginInfrastructure;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace HeuristicLab.Algorithms.DataAnalysis.IntervalArithmetic
+{
+    [Plugin("HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntergration", "3.4.0.$WCREV$")]
+    [PluginFile("HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration-3.4.dll", PluginFileType.Assembly)]
+    public class Plugin : PluginBase{
+    }
+}
Index: branches/2956_apriori_knowledge/HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration/3.4/Properties/AssemblyInfo.cs
===================================================================
--- branches/2956_apriori_knowledge/HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration/3.4/Properties/AssemblyInfo.cs	(revision 16303)
+++ branches/2956_apriori_knowledge/HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration/3.4/Properties/AssemblyInfo.cs	(revision 16303)
@@ -0,0 +1,36 @@
+﻿using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("HeuristicLab.Algorithm.DataAnalysis.KnowledgeIntegration")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("FH-Hagenberg")]
+[assembly: AssemblyProduct("HeuristicLab.Algorithm.DataAnalysis.KnowledgeIntegration")]
+[assembly: AssemblyCopyright("Copyright © FH-Hagenberg 2018")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components.  If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("5e8b5347-4281-4d89-92e5-8d81e297bbca")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("3.4.0.0")]
+[assembly: AssemblyFileVersion("3.4.0.0")]
Index: branches/2956_apriori_knowledge/HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration/3.4/Util/FormulationParser.cs
===================================================================
--- branches/2956_apriori_knowledge/HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration/3.4/Util/FormulationParser.cs	(revision 16303)
+++ branches/2956_apriori_knowledge/HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration/3.4/Util/FormulationParser.cs	(revision 16303)
@@ -0,0 +1,77 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration.IntervalArithmetic;
+
+namespace HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration.Util {
+  public class FormulationParser {
+
+    private static readonly char LEFT_SQUARE_BRACKET = '[';
+    private static readonly char RIGHT_SQUARE_BRACKET = ']';
+    private static readonly char POSITIVE = '+';
+    private static readonly char NEGATIVE = '-';
+    private static readonly string INFINITY = "Inf";
+    private static readonly string INTERVAL_SEPERATOR = "..";
+
+
+    public Interval Parse(string intervalString) {
+      var interval = new Interval();
+      //Remove all whitespaces from interval string
+      intervalString = intervalString.Replace(" ", String.Empty);
+
+      if (intervalString[0] == LEFT_SQUARE_BRACKET) {
+        //Closed interval start
+      } else if (intervalString[0] == RIGHT_SQUARE_BRACKET) {
+        //Opened interval start
+      } else {
+        throw new Exception("Interval has no valid starting symbol!");
+      }
+      if (intervalString[intervalString.Length-1] == LEFT_SQUARE_BRACKET) {
+        //Closed interval start
+      } else if (intervalString[intervalString.Length - 1] == RIGHT_SQUARE_BRACKET) {
+        //Opened interval start
+      } else {
+        throw new Exception("Interval has no valid ending symbol!");
+      }
+      //Get lower bound of interval
+      var splited = intervalString.Substring(1, intervalString.Length-2).Split(new string[] { INTERVAL_SEPERATOR }, StringSplitOptions.None);
+      if (splited.Length != 2)
+        throw new Exception("Interval has no lower/upper-bound seperator!");
+      else {
+        for (int i = 0; i < 2; ++i) { 
+          if (int.TryParse(splited[i], out int lower)) {
+            if (i == 0)
+              interval.LowerBound = lower;
+            else
+              interval.UpperBound = lower;
+          } else if (splited[i][0] == POSITIVE || splited[i][0] == NEGATIVE) {
+            bool isPositive = true;
+            if (splited[i][0] == POSITIVE) {
+              isPositive = true;
+            } else if (splited[i][0] == NEGATIVE) {
+              isPositive = false;
+            }
+            if (splited[i].Substring(1, splited[i].Length-1) != INFINITY) {
+              throw new Exception("Lower bound is not a valid interval bound!");
+            } else {
+              if (isPositive) { 
+                if (i == 0)
+                  interval.LowerBound = int.MaxValue;
+              } else { 
+                if (i == 0)
+                  interval.LowerBound = int.MinValue;
+                }
+            }
+          } else {
+            throw new Exception("Lower bound is not a valid interval bound!");
+          }
+        }
+      }
+
+
+      return null;
+    }
+  }
+}
Index: branches/2956_apriori_knowledge/HeuristicLab.Algorithms.DataAnalysis.Views/3.4/HeuristicLab.Algorithms.DataAnalysis.Views-3.4.csproj
===================================================================
--- branches/2956_apriori_knowledge/HeuristicLab.Algorithms.DataAnalysis.Views/3.4/HeuristicLab.Algorithms.DataAnalysis.Views-3.4.csproj	(revision 16295)
+++ branches/2956_apriori_knowledge/HeuristicLab.Algorithms.DataAnalysis.Views/3.4/HeuristicLab.Algorithms.DataAnalysis.Views-3.4.csproj	(revision 16303)
@@ -353,4 +353,13 @@
 </PreBuildEvent>
   </PropertyGroup>
+  <PropertyGroup>
+    <PreBuildEvent>set Path=%25Path%25;$(ProjectDir);$(SolutionDir)
+set ProjectDir=$(ProjectDir)
+set SolutionDir=$(SolutionDir)
+set Outdir=$(Outdir)
+
+call PreBuildEvent.cmd
+</PreBuildEvent>
+  </PropertyGroup>
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
Index: branches/2956_apriori_knowledge/HeuristicLab.Data.Views/3.3/HeuristicLab.Data.Views-3.3.csproj
===================================================================
--- branches/2956_apriori_knowledge/HeuristicLab.Data.Views/3.3/HeuristicLab.Data.Views-3.3.csproj	(revision 16295)
+++ branches/2956_apriori_knowledge/HeuristicLab.Data.Views/3.3/HeuristicLab.Data.Views-3.3.csproj	(revision 16303)
@@ -177,4 +177,10 @@
       <DependentUpon>StringConvertibleMatrixRowVisibilityDialog.cs</DependentUpon>
     </Compile>
+    <Compile Include="StringIntervalView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="StringIntervalView.Designer.cs">
+      <DependentUpon>StringIntervalView.cs</DependentUpon>
+    </Compile>
     <Compile Include="StringConvertibleValueTupleView.cs">
       <SubType>UserControl</SubType>
@@ -272,4 +278,8 @@
       <Name>HeuristicLab.PluginInfrastructure-3.3</Name>
       <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Problems.DataAnalysis\3.4\HeuristicLab.Problems.DataAnalysis-3.4.csproj">
+      <Project>{DF87C13E-A889-46FF-8153-66DCAA8C5674}</Project>
+      <Name>HeuristicLab.Problems.DataAnalysis-3.4</Name>
     </ProjectReference>
   </ItemGroup>
@@ -290,4 +300,9 @@
       <Install>true</Install>
     </BootstrapperPackage>
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="StringIntervalView.resx">
+      <DependentUpon>StringIntervalView.cs</DependentUpon>
+    </EmbeddedResource>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
Index: branches/2956_apriori_knowledge/HeuristicLab.Data.Views/3.3/StringIntervalView.Designer.cs
===================================================================
--- branches/2956_apriori_knowledge/HeuristicLab.Data.Views/3.3/StringIntervalView.Designer.cs	(revision 16303)
+++ branches/2956_apriori_knowledge/HeuristicLab.Data.Views/3.3/StringIntervalView.Designer.cs	(revision 16303)
@@ -0,0 +1,146 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2018 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+namespace HeuristicLab.Data.Views {
+  public partial class StringIntervalView {
+    /// <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.Item1View = new HeuristicLab.Data.Views.StringConvertibleValueView();
+            this.Item2View = new HeuristicLab.Data.Views.StringConvertibleValueView();
+            this.Item1Label = new System.Windows.Forms.Label();
+            this.Item2Label = new System.Windows.Forms.Label();
+            this.label1 = new System.Windows.Forms.Label();
+            this.Item3View = new HeuristicLab.Data.Views.StringConvertibleValueView();
+            this.SuspendLayout();
+            // 
+            // Item1View
+            // 
+            this.Item1View.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
+            | System.Windows.Forms.AnchorStyles.Right)));
+            this.Item1View.Caption = "StringIntervalView View";
+            this.Item1View.Content = null;
+            this.Item1View.LabelVisible = false;
+            this.Item1View.Location = new System.Drawing.Point(63, 29);
+            this.Item1View.Name = "Item1View";
+            this.Item1View.ReadOnly = false;
+            this.Item1View.Size = new System.Drawing.Size(252, 20);
+            this.Item1View.TabIndex = 0;
+            // 
+            // Item2View
+            // 
+            this.Item2View.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
+            | System.Windows.Forms.AnchorStyles.Right)));
+            this.Item2View.Caption = "StringIntervalView View";
+            this.Item2View.Content = null;
+            this.Item2View.LabelVisible = false;
+            this.Item2View.Location = new System.Drawing.Point(63, 55);
+            this.Item2View.Name = "Item2View";
+            this.Item2View.ReadOnly = false;
+            this.Item2View.Size = new System.Drawing.Size(252, 20);
+            this.Item2View.TabIndex = 1;
+            // 
+            // Item1Label
+            // 
+            this.Item1Label.AutoSize = true;
+            this.Item1Label.Location = new System.Drawing.Point(3, 32);
+            this.Item1Label.Name = "Item1Label";
+            this.Item1Label.Size = new System.Drawing.Size(64, 13);
+            this.Item1Label.TabIndex = 2;
+            this.Item1Label.Text = "Formulation:";
+            // 
+            // Item2Label
+            // 
+            this.Item2Label.AutoSize = true;
+            this.Item2Label.Location = new System.Drawing.Point(3, 58);
+            this.Item2Label.Name = "Item2Label";
+            this.Item2Label.Size = new System.Drawing.Size(45, 13);
+            this.Item2Label.TabIndex = 3;
+            this.Item2Label.Text = "Interval:";
+            // 
+            // label1
+            // 
+            this.label1.AutoSize = true;
+            this.label1.Location = new System.Drawing.Point(3, 6);
+            this.label1.Name = "label1";
+            this.label1.Size = new System.Drawing.Size(38, 13);
+            this.label1.TabIndex = 5;
+            this.label1.Text = "Name:";
+            // 
+            // Item3View
+            // 
+            this.Item3View.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
+            | System.Windows.Forms.AnchorStyles.Right)));
+            this.Item3View.Caption = "StringIntervalView View";
+            this.Item3View.Content = null;
+            this.Item3View.LabelVisible = false;
+            this.Item3View.Location = new System.Drawing.Point(63, 3);
+            this.Item3View.Name = "Item3View";
+            this.Item3View.ReadOnly = false;
+            this.Item3View.Size = new System.Drawing.Size(252, 20);
+            this.Item3View.TabIndex = 4;
+            // 
+            // StringIntervalView
+            // 
+            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
+            this.Controls.Add(this.label1);
+            this.Controls.Add(this.Item3View);
+            this.Controls.Add(this.Item1Label);
+            this.Controls.Add(this.Item2Label);
+            this.Controls.Add(this.Item1View);
+            this.Controls.Add(this.Item2View);
+            this.Name = "StringIntervalView";
+            this.Size = new System.Drawing.Size(318, 230);
+            this.ResumeLayout(false);
+            this.PerformLayout();
+
+    }
+
+    #endregion
+
+    protected StringConvertibleValueView Item1View;
+    protected StringConvertibleValueView Item2View;
+    protected System.Windows.Forms.Label Item1Label;
+    protected System.Windows.Forms.Label Item2Label;
+    protected System.Windows.Forms.Label label1;
+    protected StringConvertibleValueView stringConvertibleValueView1;
+    protected StringConvertibleValueView Item3View;
+  }
+}
Index: branches/2956_apriori_knowledge/HeuristicLab.Data.Views/3.3/StringIntervalView.cs
===================================================================
--- branches/2956_apriori_knowledge/HeuristicLab.Data.Views/3.3/StringIntervalView.cs	(revision 16303)
+++ branches/2956_apriori_knowledge/HeuristicLab.Data.Views/3.3/StringIntervalView.cs	(revision 16303)
@@ -0,0 +1,80 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2018 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.Windows.Forms;
+using HeuristicLab.Core.Views;
+using HeuristicLab.MainForm;
+using HeuristicLab.MainForm.WindowsForms;
+using HeuristicLab.Problems.DataAnalysis.Interfaces;
+
+namespace HeuristicLab.Data.Views {
+  [View("StringInterval View")]
+  [Content(typeof(IInterval), true)]
+  public partial class StringIntervalView : AsynchronousContentView {
+
+    public new IInterval Content {
+      get { return (IInterval)base.Content; }
+      set { base.Content = value; }
+    }
+
+    public StringIntervalView() {
+      InitializeComponent();
+    }
+
+    protected override void OnContentChanged() {
+      base.OnContentChanged();
+      if (Content != null) {
+        Item1View.Content = Content.Variable;
+        Item2View.Content = Content.Formulation;
+        Item3View.Content = new StringValue(Content.Name);
+      } else {
+        Item1View.Content = null;
+        Item2View.Content = null;
+        Item3View.Content = null;
+      }
+    }
+
+    protected override void SetEnabledStateOfControls() {
+      base.SetEnabledStateOfControls();
+      Item1View.Enabled = Content != null;
+      Item2View.Enabled = Content != null;
+      Item3View.Enabled = Content != null;
+    }
+
+    protected override void RegisterContentEvents() {
+      base.RegisterContentEvents();
+      Content.NameChanged += new EventHandler(Content_NameChanged);
+    }
+
+    protected virtual void Content_NameChanged(object sender, EventArgs e) {
+      if (InvokeRequired)
+        Invoke(new EventHandler(Content_NameChanged), sender, e);
+      else {
+        Caption = Item3View.Content.GetValue();
+      }
+    }
+
+    private void label1_Click(object sender, System.EventArgs e) {
+
+    }
+  }
+}
Index: branches/2956_apriori_knowledge/HeuristicLab.Data.Views/3.3/StringIntervalView.resx
===================================================================
--- branches/2956_apriori_knowledge/HeuristicLab.Data.Views/3.3/StringIntervalView.resx	(revision 16303)
+++ branches/2956_apriori_knowledge/HeuristicLab.Data.Views/3.3/StringIntervalView.resx	(revision 16303)
@@ -0,0 +1,120 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>
Index: branches/2956_apriori_knowledge/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Views-3.4.csproj
===================================================================
--- branches/2956_apriori_knowledge/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Views-3.4.csproj	(revision 16295)
+++ branches/2956_apriori_knowledge/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Views-3.4.csproj	(revision 16303)
@@ -206,4 +206,8 @@
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration\3.4\HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration-3.4.csproj">
+      <Project>{5e8b5347-4281-4d89-92e5-8d81e297bbca}</Project>
+      <Name>HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration-3.4</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Collections\3.3\HeuristicLab.Collections-3.3.csproj">
       <Project>{958B43BC-CC5C-4FA2-8628-2B3B01D890B6}</Project>
Index: branches/2956_apriori_knowledge/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs
===================================================================
--- branches/2956_apriori_knowledge/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs	(revision 16295)
+++ branches/2956_apriori_knowledge/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs	(revision 16303)
@@ -26,4 +26,7 @@
 using System.Threading.Tasks;
 using System.Windows.Forms;
+using HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration.Interpreter;
+using HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration.IntervalArithmetic;
+using HeuristicLab.Algorithms.DataAnalysis.KnowledgeIntegration.Util;
 using HeuristicLab.Common;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
@@ -36,4 +39,6 @@
     private Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode> foldedNodes;
     private Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode> changedNodes;
+    //private Dictionary<ISymbolicExpressionTreeNode, Interval> intervals;
+    private Dictionary<ISymbolicExpressionTreeNode, Interval> intervals;
     private Dictionary<ISymbolicExpressionTreeNode, double> nodeImpacts;
 
@@ -50,4 +55,5 @@
       changedNodes = new Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode>();
       nodeImpacts = new Dictionary<ISymbolicExpressionTreeNode, double>();
+      //intervals = new Dictionary<ISymbolicExpressionTreeNode, Interval>();
       this.Caption = "Interactive Solution Simplifier";
       this.impactCalculator = impactCalculator;
@@ -185,4 +191,14 @@
       progress.Start("Calculate Impact and Replacement Values ...");
       var impactAndReplacementValues = await Task.Run(() => CalculateImpactAndReplacementValues(tree));
+      var interpreter = new SymbolicDataAnalysisIntervalArithmeticInterpreter();
+
+      //var intervalParam = ((IRegressionProblemData)Content.ProblemData).IntervalVariable;
+      var customIntervals = new Dictionary<String, Interval>();
+      var parser = new FormulationParser();
+      //foreach (var ci in intervalParam) {
+      //var inter = parser.Parse(ci.Formulation.GetValue());
+      //customIntervals.Add(ci.Variable.GetValue(), new Interval(0, 1));
+      //}
+      var resultInterval = interpreter.GetSymbolicExressionTreeIntervals(tree, Content.ProblemData.Dataset, Content.ProblemData.TrainingIndices, out intervals);
       await Task.Delay(500); // wait for progressbar to finish animation
       var replacementValues = impactAndReplacementValues.ToDictionary(x => x.Key, x => x.Value.Item2);
@@ -190,7 +206,18 @@
         foldedNodes[pair.Key] = MakeConstantTreeNode(pair.Value);
       }
+      //Instruction currentInstr = instructions.NextInstruction();
+      //while (instructions.HasNextInstruction()) {
+      //  //intervals[currentInstr.dynamicNode] = (Interval)currentInstr.data;
+      //  intervals.Add(Tuple.Create(currentInstr.dynamicNode, (Interval)currentInstr.data));
+      //  currentInstr = instructions.NextInstruction();
+      //}
+      
+      
+
+      //intervals.Add(Tuple.Create(currentInstr.dynamicNode, (Interval)currentInstr.data));
       nodeImpacts = impactAndReplacementValues.ToDictionary(x => x.Key, x => x.Value.Item1);
       progress.Finish();
-      PaintNodeImpacts();
+      PaintIntervals();
+      //PaintNodeImpacts();
     }
 
@@ -253,4 +280,49 @@
     }
 
+    private void PaintIntervals() {
+      int node = 0;
+      var impacts = nodeImpacts.Values;
+      double max = impacts.Max();
+      double min = impacts.Min();
+
+      foreach (ISymbolicExpressionTreeNode treeNode in Content.Model.SymbolicExpressionTree.IterateNodesPrefix()) {
+        VisualTreeNode<ISymbolicExpressionTreeNode> visualTree = treeChart.GetVisualSymbolicExpressionTreeNode(treeNode);
+
+        if (visualTree != null) { 
+          visualTree.ToolTip = visualTree.Content.ToString();
+          //visualTree.ToolTip += String.Format($"{Environment.NewLine}Intervals: [{intervals[node].Item2.LowerBound:E4} ... {intervals[node].Item2.UpperBound:E4}]{Environment.NewLine}");
+          visualTree.ToolTip += String.Format($"{Environment.NewLine}Intervals: [{intervals[treeNode].LowerBound:E4} ... {intervals[treeNode].UpperBound:E4}]{Environment.NewLine}]");
+          node++;
+          
+          if (!(treeNode is ConstantTreeNode) && nodeImpacts.ContainsKey(treeNode)) {
+            double impact = nodeImpacts[treeNode];
+
+            // impact = 0 if no change
+            // impact < 0 if new solution is better
+            // impact > 0 if new solution is worse
+            if (impact < 0.0) {
+              visualTree.FillColor = Color.FromArgb((int)(impact / min * 255), Color.Red);
+            } else if (impact.IsAlmost(0.0)) {
+              visualTree.FillColor = Color.White;
+            } else {
+              // max is guaranteed to be > 0
+              visualTree.FillColor = Color.FromArgb((int)(impact / max * 255), Color.Green);
+            }
+            visualTree.ToolTip += String.Format($"{Environment.NewLine} Node impact: {impact:E4}");
+            var constantReplacementNode = foldedNodes[treeNode] as ConstantTreeNode;
+            if (constantReplacementNode != null) {
+              visualTree.ToolTip += String.Format($"{Environment.NewLine} Replacement value: {constantReplacementNode.Value:E4}");
+            }
+          }
+          if (changedNodes.ContainsKey(treeNode)) {
+            visualTree.LineColor = Color.DodgerBlue;
+          } else if (treeNode is ConstantTreeNode && foldedNodes.ContainsKey(treeNode)) {
+            visualTree.LineColor = Color.DarkOrange;
+          }
+        }
+      }
+      treeChart.RepaintNodes();
+    }
+
     private void PaintNodeImpacts() {
       var impacts = nodeImpacts.Values;
Index: branches/2956_apriori_knowledge/HeuristicLab.Problems.DataAnalysis/3.4/HeuristicLab.Problems.DataAnalysis-3.4.csproj
===================================================================
--- branches/2956_apriori_knowledge/HeuristicLab.Problems.DataAnalysis/3.4/HeuristicLab.Problems.DataAnalysis-3.4.csproj	(revision 16295)
+++ branches/2956_apriori_knowledge/HeuristicLab.Problems.DataAnalysis/3.4/HeuristicLab.Problems.DataAnalysis-3.4.csproj	(revision 16303)
@@ -176,4 +176,5 @@
     <Compile Include="Interfaces\IDataset.cs" />
     <Compile Include="Interfaces\IDependencyCalculator.cs" />
+    <Compile Include="Interfaces\IInterval.cs" />
     <Compile Include="Interfaces\ITransformation.cs" />
     <Compile Include="Interfaces\ITransformationMapper.cs" />
@@ -190,4 +191,5 @@
     <Compile Include="Interfaces\TimeSeriesPrognosis\ITimeSeriesPrognosisProblemData.cs" />
     <Compile Include="Interfaces\TimeSeriesPrognosis\ITimeSeriesPrognosisSolution.cs" />
+    <Compile Include="IntervalItem.cs" />
     <Compile Include="ModifiableDataset.cs" />
     <Compile Include="OnlineCalculators\AutoCorrelationCalculator.cs" />
Index: branches/2956_apriori_knowledge/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionProblemData.cs
===================================================================
--- branches/2956_apriori_knowledge/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionProblemData.cs	(revision 16295)
+++ branches/2956_apriori_knowledge/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionProblemData.cs	(revision 16303)
@@ -34,4 +34,5 @@
   public class RegressionProblemData : DataAnalysisProblemData, IRegressionProblemData, IStorableContent {
     protected const string TargetVariableParameterName = "TargetVariable";
+    protected const string VariableRangeParameterName = "VariableRanges";
     public string Filename { get; set; }
 
@@ -91,7 +92,12 @@
       problemData.Parameters.Add(new FixedValueParameter<IntRange>(TestPartitionParameterName, "", (IntRange)new IntRange(0, 0).AsReadOnly()));
       problemData.Parameters.Add(new ConstrainedValueParameter<StringValue>(TargetVariableParameterName, new ItemSet<StringValue>()));
+      problemData.Parameters.Add(new OptionalValueParameter<DoubleMatrix>(VariableRangeParameterName, ""));
       emptyProblemData = problemData;
     }
     #endregion
+
+    public OptionalValueParameter<DoubleMatrix> VariableRangeParameter {
+      get { return (OptionalValueParameter<DoubleMatrix>)Parameters[VariableRangeParameterName]; }
+    }
 
     public IConstrainedValueParameter<StringValue> TargetVariableParameter {
@@ -120,4 +126,7 @@
     }
 
+    public DoubleMatrix VariableRanges {
+      get { return VariableRangeParameter.Value; }
+    }
 
     [StorableConstructor]
@@ -152,4 +161,19 @@
       var variables = InputVariables.Select(x => x.AsReadOnly()).ToList();
       Parameters.Add(new ConstrainedValueParameter<StringValue>(TargetVariableParameterName, new ItemSet<StringValue>(variables), variables.Where(x => x.Value == targetVariable).First()));
+
+      DoubleMatrix variableRanges = new DoubleMatrix(variables.Count, 2, new string[] { "Lower Bound", "Upper Bound" }, variables.Select(x => x.Value));
+      Parameters.Add(new FixedValueParameter<DoubleMatrix>(VariableRangeParameterName, variableRanges));
+
+      int row = 0;
+      foreach (var variable in variables) {
+        IList<double> values = new List<double>();
+        foreach (var value in dataset.GetReadOnlyDoubleValues(variable.Value)) {
+          values.Add(value);
+        }
+        variableRanges[row, 0] = values.Min();
+        variableRanges[row, 1] = values.Max();
+        ++row;
+      }
+
       RegisterParameterEvents();
     }
Index: branches/2956_apriori_knowledge/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IInterval.cs
===================================================================
--- branches/2956_apriori_knowledge/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IInterval.cs	(revision 16303)
+++ branches/2956_apriori_knowledge/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IInterval.cs	(revision 16303)
@@ -0,0 +1,16 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Problems.DataAnalysis.Interfaces {
+  public interface IInterval : IItem, INamedItem {
+    IStringConvertibleValue Variable { get; }
+    IStringConvertibleValue Formulation { get; }
+  }
+}
Index: branches/2956_apriori_knowledge/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/Regression/IRegressionProblemData.cs
===================================================================
--- branches/2956_apriori_knowledge/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/Regression/IRegressionProblemData.cs	(revision 16295)
+++ branches/2956_apriori_knowledge/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/Regression/IRegressionProblemData.cs	(revision 16303)
@@ -21,8 +21,11 @@
 
 using System.Collections.Generic;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
 
 namespace HeuristicLab.Problems.DataAnalysis {
   public interface IRegressionProblemData : IDataAnalysisProblemData {
     string TargetVariable { get; set; }
+    DoubleMatrix VariableRanges { get; }
 
     IEnumerable<double> TargetVariableValues { get; }
Index: branches/2956_apriori_knowledge/HeuristicLab.Problems.DataAnalysis/3.4/IntervalItem.cs
===================================================================
--- branches/2956_apriori_knowledge/HeuristicLab.Problems.DataAnalysis/3.4/IntervalItem.cs	(revision 16303)
+++ branches/2956_apriori_knowledge/HeuristicLab.Problems.DataAnalysis/3.4/IntervalItem.cs	(revision 16303)
@@ -0,0 +1,53 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis.Interfaces;
+
+namespace HeuristicLab.Problems.DataAnalysis {
+  [StorableClass]
+  public class IntervalItem : NamedItem, IInterval {
+    public IntervalItem() : base() {
+      Name = "Constraint";
+      Variable.SetValue("");
+      Formulation.SetValue("");
+    }
+
+    public IntervalItem(string name, string variable, string formulation) {
+      Name = name;
+      Variable.SetValue(variable);
+      Formulation.SetValue(formulation);
+    }
+
+    [StorableConstructor]
+    protected IntervalItem(bool deserializing) : base(deserializing) { }
+    protected IntervalItem(IntervalItem original, Cloner cloner)
+      : base(original, cloner) {
+      variable = original.variable;
+      formulation = original.formulation;
+      name = original.name;
+    }
+
+    protected IStringConvertibleValue variable = new StringValue();
+
+    public IStringConvertibleValue Variable {
+      get { return variable; }
+    }
+
+    protected IStringConvertibleValue formulation = new StringValue();
+    public IStringConvertibleValue Formulation {
+      get { return formulation; }
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new IntervalItem(this, cloner);
+    }
+
+
+  }
+}
