Index: branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LCSAdaptedGeneticAlgorithm.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LCSAdaptedGeneticAlgorithm.cs	(revision 9090)
+++ branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LCSAdaptedGeneticAlgorithm.cs	(revision 9105)
@@ -52,4 +52,7 @@
       get { return (ValueLookupParameter<IOperator>)Parameters["Crossover"]; }
     }
+    public ValueLookupParameter<IOperator> AfterCrossoverParameter {
+      get { return (ValueLookupParameter<IOperator>)Parameters["AfterCrossover"]; }
+    }
     public ValueLookupParameter<PercentValue> MutationProbabilityParameter {
       get { return (ValueLookupParameter<PercentValue>)Parameters["MutationProbability"]; }
@@ -102,4 +105,5 @@
       Parameters.Add(new ValueLookupParameter<IOperator>("Selector", "The operator used to select solutions for reproduction."));
       Parameters.Add(new ValueLookupParameter<IOperator>("Crossover", "The operator used to cross solutions."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("AfterCrossover", "The operator executed after crossing the solutions."));
       Parameters.Add(new ValueLookupParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution."));
       Parameters.Add(new ValueLookupParameter<IOperator>("Mutator", "The operator used to mutate solutions."));
@@ -121,12 +125,9 @@
       UniformSubScopesProcessor uniformSubScopesProcessor1 = new UniformSubScopesProcessor();
       Placeholder crossover = new Placeholder();
-      DataReducer dataReducer = new DataReducer();
+      Placeholder afterCrossover = new Placeholder();
       StochasticBranch stochasticBranch = new StochasticBranch();
       Placeholder mutator = new Placeholder();
       SubScopesRemover subScopesRemover = new SubScopesRemover();
       SubScopesCounter subScopesCounter = new SubScopesCounter();
-      SubScopesProcessor subScopesProcessor2 = new SubScopesProcessor();
-      BestSelector bestSelector = new BestSelector();
-      RightReducer rightReducer = new RightReducer();
       MergingReducer mergingReducer = new MergingReducer();
       IntCounter intCounter = new IntCounter();
@@ -151,9 +152,6 @@
       crossover.OperatorParameter.ActualName = "Crossover";
 
-      dataReducer.Name = "Average Fitness of Parents";
-      dataReducer.ParameterToReduce.ActualName = "Fitness";
-      dataReducer.ReductionOperation.Value = new ReductionOperation(ReductionOperations.Avg);
-      dataReducer.TargetParameter.ActualName = "Fitness";
-      dataReducer.TargetOperation.Value = new ReductionOperation(ReductionOperations.Assign);
+      afterCrossover.Name = "AfterCrossover";
+      afterCrossover.OperatorParameter.ActualName = "AfterCrossover";
 
       stochasticBranch.ProbabilityParameter.ActualName = "MutationProbability";
@@ -167,9 +165,4 @@
       subScopesCounter.Name = "Increment EvaluatedSolutions";
       subScopesCounter.ValueParameter.ActualName = EvaluatedSolutionsParameter.Name;
-
-      bestSelector.CopySelected = new BoolValue(false);
-      bestSelector.MaximizationParameter.ActualName = "Maximization";
-      bestSelector.NumberOfSelectedSubScopesParameter.ActualName = "N";
-      bestSelector.QualityParameter.ActualName = "Fitness";
 
       intCounter.Increment = new IntValue(1);
@@ -195,10 +188,10 @@
       subScopesProcessor1.Operators.Add(new EmptyOperator());
       subScopesProcessor1.Operators.Add(childrenCreator);
-      subScopesProcessor1.Successor = subScopesProcessor2;
+      subScopesProcessor1.Successor = mergingReducer;
       childrenCreator.Successor = uniformSubScopesProcessor1;
       uniformSubScopesProcessor1.Operator = crossover;
       uniformSubScopesProcessor1.Successor = subScopesCounter;
-      crossover.Successor = dataReducer;
-      dataReducer.Successor = stochasticBranch;
+      crossover.Successor = afterCrossover;
+      afterCrossover.Successor = stochasticBranch;
       stochasticBranch.FirstBranch = mutator;
       stochasticBranch.SecondBranch = null;
@@ -207,9 +200,4 @@
       subScopesRemover.Successor = null;
       subScopesCounter.Successor = null;
-      subScopesProcessor2.Operators.Add(bestSelector);
-      subScopesProcessor2.Operators.Add(new EmptyOperator());
-      subScopesProcessor2.Successor = mergingReducer;
-      bestSelector.Successor = rightReducer;
-      rightReducer.Successor = null;
       mergingReducer.Successor = intCounter;
       intCounter.Successor = comparator;
Index: branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystemMainLoop.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystemMainLoop.cs	(revision 9090)
+++ branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystemMainLoop.cs	(revision 9105)
@@ -50,4 +50,7 @@
       get { return (IConstrainedValueParameter<IManipulator>)Parameters["Mutator"]; }
     }
+    public IConstrainedValueParameter<IOperator> AfterCrossoverParameter {
+      get { return (IConstrainedValueParameter<IOperator>)Parameters["AfterCrossover"]; }
+    }
     #endregion
 
@@ -57,9 +60,12 @@
     private PredictionArrayCalculator predictionArrayCalculator;
     private ActionSelector actionSelector;
+    private DoDeletionBeforeCoveringOperator doDeletionBeforeCovering;
     private CoveringOperator covering;
+    private ConditionalSelector subsumptionSelector;
 
     private Placeholder evaluator;
     private Placeholder actionExecuter;
     private Placeholder classifierFetcher;
+    private Placeholder actionSetSubsumption;
     #endregion
 
@@ -85,4 +91,6 @@
       test.IntegerVectorParameter.ActualName = "CombinedIntegerVector";
       Parameters.Add(new OptionalConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions.", new ItemSet<IManipulator>() { new UniformOnePositionManipulator() }, test));
+      XCSAfterCrossoverOperator afterCrossover = new XCSAfterCrossoverOperator();
+      Parameters.Add(new ConstrainedValueParameter<IOperator>("AfterCrossover", "The operator used to select solutions for reproduction.", new ItemSet<IOperator>() { new XCSAfterCrossoverOperator() }, afterCrossover));
       #endregion
 
@@ -91,4 +99,5 @@
       ConditionalBranch initialPopulationConditionalBranch = new ConditionalBranch();
       initialSolutionsCreator = new SolutionsCreator();
+      Assigner initialPopulationSizeAssigner = new Assigner();
       IntCounter iterationCounter = new IntCounter();
       UniformSubScopesProcessor matchCondtionSubScopesProcessor = new UniformSubScopesProcessor();
@@ -102,7 +111,19 @@
       SubScopesProcessor matchSetSubScopesProcessor = new SubScopesProcessor();
       CountNumberOfUniqueActions countNumberOfUniqueActions = new CountNumberOfUniqueActions();
+      doDeletionBeforeCovering = new DoDeletionBeforeCoveringOperator();
+      ConditionalBranch doDeletionBeforeCoveringConditionalBranch = new ConditionalBranch();
+      MergingReducer matchSetMergingReducerForDeletion = new MergingReducer();
+      SubScopeVariableCopier subscopeVariableCopier = new SubScopeVariableCopier();
+      XCSDeletionOperator deletionOperator = new XCSDeletionOperator();
+      ConditionalSelector deletionSelector = new ConditionalSelector();
+      LeftReducer leftReducerAfterDeletionSelection = new LeftReducer();
+      UniformSubScopesProcessor matchConditionAfterDeletionSubScopesProcessor = new UniformSubScopesProcessor();
+      ConditionalSelector conditionMatchSelectorAfterDeletion = new ConditionalSelector();
+      SubScopesProcessor matchSetAfterDeletionSubScopesProcessor = new SubScopesProcessor();
+      CountNumberOfUniqueActions countNumberOfUniqueActionsAfterDeletion = new CountNumberOfUniqueActions();
+      SubScopesProcessor coveringAfterDeletionSubScopesProcessor = new SubScopesProcessor();
       covering = new CoveringOperator();
-      MergingReducer mergingReducer = new MergingReducer();
-      MergingReducer mergingReducerWithSuccessor = new MergingReducer();
+      MergingReducer actionSetMergingReducer = new MergingReducer();
+      MergingReducer matchSetMergingReducer = new MergingReducer();
       evaluator = new Placeholder();
       SubScopesProcessor actionSetSubScopesProcessor = new SubScopesProcessor();
@@ -112,22 +133,37 @@
       SumAccuracy sumAccuracy = new SumAccuracy();
       UniformSubScopesProcessor updateParametersSubScopesProcessor = new UniformSubScopesProcessor();
+      ConditionalBranch actionSetSubsumptionBranch = new ConditionalBranch();
+      subsumptionSelector = new ConditionalSelector();
+      LeftReducer leftReducer = new LeftReducer();
+      XCSCheckIfGAShouldBeApplied checkIfGAShouldRun = new XCSCheckIfGAShouldBeApplied();
+      ConditionalBranch runGAConditionalBranch = new ConditionalBranch();
+      UniformSubScopesProcessor timestampAssignerSubscopeProcessor = new UniformSubScopesProcessor();
+      Assigner timestampAssigner = new Assigner();
       LCSAdaptedGeneticAlgorithm adaptedGeneticAlgorithmMainLoop = new LCSAdaptedGeneticAlgorithm();
+      IntCounter currentPopulationSizeCounter = new IntCounter();
+      CalculateNumberOfDeletionsOperator calculateNumberOfDeletions = new CalculateNumberOfDeletionsOperator();
+      XCSDeletionOperator deletionOperatorAfterGA = new XCSDeletionOperator();
+      ConditionalSelector deletionSelectorAfterGA = new ConditionalSelector();
+      LeftReducer leftReducerAfterGA = new LeftReducer();
 
       classifierFetcher = new Placeholder();
       actionExecuter = new Placeholder();
+      actionSetSubsumption = new Placeholder();
 
       variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("ZeroIntValue", new IntValue(0)));
       variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("OneIntValue", new IntValue(1)));
       variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Iteration", new IntValue(0)));
+      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("CurrentPopulationSize", new IntValue(0)));
 
       initialPopulationConditionalBranch.ConditionParameter.ActualName = "CreateInitialPopulation";
 
       initialSolutionsCreator.NumberOfSolutionsParameter.ActualName = "N";
+
+      initialPopulationSizeAssigner.LeftSideParameter.ActualName = "CurrentPopulationSize";
+      initialPopulationSizeAssigner.RightSideParameter.ActualName = "N";
 
       iterationCounter.ValueParameter.ActualName = "Iteration";
       iterationCounter.IncrementParameter.ActualName = "OneIntValue";
 
-      matchCondtionSubScopesProcessor.Operator = matchConditionOperator;
-
       matchConditionOperator.MatchParameter.ActualName = "CombinedIntegerVector";
 
@@ -135,9 +171,35 @@
       conditionMatchSelector.ConditionParameter.ActualName = "MatchCondition";
 
+      conditionMatchSelectorAfterDeletion.CopySelected = new BoolValue(false);
+      conditionMatchSelectorAfterDeletion.ConditionParameter.ActualName = "MatchCondition";
+
       countNumberOfUniqueActions.ClassifiersParameter.ActualName = "CombinedIntegerVector";
+
+      countNumberOfUniqueActionsAfterDeletion.ClassifiersParameter.ActualName = "CombinedIntegerVector";
+
+      subscopeVariableCopier.SubScopeIndexParameter.Value = new IntValue(1);
+
+      doDeletionBeforeCovering.CurrentPopulationSizeParameter.ActualName = "CurrentPopulationSize";
+      doDeletionBeforeCovering.NumberOfUniqueActionsParameter.ActualName = countNumberOfUniqueActions.NumberOfUniqueActionsParameter.ActualName;
+      doDeletionBeforeCovering.PopulationSizeParameter.ActualName = "N";
+
+      doDeletionBeforeCoveringConditionalBranch.ConditionParameter.ActualName = doDeletionBeforeCovering.DoDeletionParameter.ActualName;
+
+      deletionOperator.NumberToDeleteParameter.ActualName = doDeletionBeforeCovering.NumberToDeleteParameter.ActualName;
+      deletionOperator.AverageActionSetSizesParameter.ActualName = "AverageActionSetSize";
+      deletionOperator.FitnessesParameter.ActualName = "Fitness";
+      deletionOperator.NumerositiesParameter.ActualName = "Numerosity";
+      deletionOperator.ExperiencesParameter.ActualName = "Experience";
+      deletionOperator.ThetaDeletionParameter.ActualName = "ThetaDeletion";
+      deletionOperator.DeltaParameter.ActualName = "Delta";
+      deletionOperator.RandomParameter.ActualName = "Random";
+
+      deletionSelector.ConditionParameter.ActualName = deletionOperator.HasToBeDeletedVariableName;
+      deletionSelector.CopySelected = new BoolValue(false);
 
       covering.ActionsInMatchSetParameter.ActualName = countNumberOfUniqueActions.UniqueActionsParameter.ActualName;
       covering.ParallelParameter.Value.Value = true;
       covering.RandomParameter.ActualName = "Random";
+      covering.CurrentPopulationSizeParameter.ActualName = "CurrentPopulationSize";
 
       matchActionSubScopesProcessor.Operator = matchActionOperator;
@@ -155,6 +217,10 @@
       actionMatchSelector.ConditionParameter.ActualName = "MatchAction";
 
+      actionSetSubsumptionBranch.ConditionParameter.ActualName = "DoActionSetSubsumption";
+
+      subsumptionSelector.CopySelected = new BoolValue(false);
+
       SelectorParameter.Value.CopySelected = new BoolValue(true);
-      SelectorParameter.Value.NumberOfSelectedSubScopesParameter.Value = new IntValue(200);
+      SelectorParameter.Value.NumberOfSelectedSubScopesParameter.Value = new IntValue(4);
 
       evaluator.Name = "Evaluator";
@@ -176,4 +242,29 @@
       sumAccuracy.AccuracyParameter.ActualName = calculateAccuracy.AccuracyParameter.ActualName;
       sumAccuracy.NumerosityParameter.ActualName = "Numerosity";
+
+      //BEGIN parameters have to be set differently
+      checkIfGAShouldRun.TimeStampsParameter.ActualName = "Timestamp";
+      checkIfGAShouldRun.NumerositiesParameter.ActualName = "Numerosity";
+      checkIfGAShouldRun.ThetaGAParameter.ActualName = "ThetaGA";
+      //END
+      checkIfGAShouldRun.IterationParameter.ActualName = iterationCounter.ValueParameter.ActualName;
+
+      runGAConditionalBranch.ConditionParameter.ActualName = checkIfGAShouldRun.RunGAParameter.ActualName;
+
+      timestampAssigner.LeftSideParameter.ActualName = "Timestamp";
+      timestampAssigner.RightSideParameter.ActualName = iterationCounter.ValueParameter.ActualName;
+
+      afterCrossover.NumerosityParameter.ActualName = "Numerosity";
+      afterCrossover.ExperienceParameter.ActualName = "Experience";
+      afterCrossover.TimestampParameter.ActualName = "Timestamp";
+      afterCrossover.CurrentIterationParameter.ActualName = "Iteration";
+      afterCrossover.FitnessParameter.ActualName = "Fitness";
+      afterCrossover.AverageActionSetSizeParameter.ActualName = "AverageActionSetSize";
+      afterCrossover.PredictionParameter.ActualName = "Prediction";
+      afterCrossover.ErrorParameter.ActualName = "Error";
+      afterCrossover.ParentFitnessParameter.ActualName = "Fitness";
+      afterCrossover.ParentErrorParameter.ActualName = "Error";
+      afterCrossover.ParentPredictionParameter.ActualName = "Prediction";
+      afterCrossover.ParentAverageActionSetSizeParameter.ActualName = "AverageActionSetSize";
 
       adaptedGeneticAlgorithmMainLoop.SelectorParameter.ActualName = SelectorParameter.Name;
@@ -183,7 +274,25 @@
       adaptedGeneticAlgorithmMainLoop.MaximumGenerationsParameter.ActualName = "ZeroIntValue";
       adaptedGeneticAlgorithmMainLoop.QualityParameter.ActualName = "Fitness";
-      //needed?
       adaptedGeneticAlgorithmMainLoop.MutationProbabilityParameter.Value = new PercentValue(10);
       adaptedGeneticAlgorithmMainLoop.MaximizationParameter.Value = new BoolValue(true);
+      adaptedGeneticAlgorithmMainLoop.AfterCrossoverParameter.ActualName = AfterCrossoverParameter.Name;
+
+      currentPopulationSizeCounter.ValueParameter.ActualName = "CurrentPopulationSize";
+      currentPopulationSizeCounter.Increment = new IntValue(2);
+
+      calculateNumberOfDeletions.CurrentPopulationSizeParameter.ActualName = "CurrentPopulationSize";
+      calculateNumberOfDeletions.PopulationSizeParameter.ActualName = "N";
+
+      deletionOperatorAfterGA.NumberToDeleteParameter.ActualName = calculateNumberOfDeletions.NumberOfDeletionsParameter.ActualName;
+      deletionOperatorAfterGA.AverageActionSetSizesParameter.ActualName = "AverageActionSetSize";
+      deletionOperatorAfterGA.FitnessesParameter.ActualName = "Fitness";
+      deletionOperatorAfterGA.NumerositiesParameter.ActualName = "Numerosity";
+      deletionOperatorAfterGA.ExperiencesParameter.ActualName = "Experience";
+      deletionOperatorAfterGA.ThetaDeletionParameter.ActualName = "ThetaDeletion";
+      deletionOperatorAfterGA.DeltaParameter.ActualName = "Delta";
+      deletionOperatorAfterGA.RandomParameter.ActualName = "Random";
+
+      deletionSelectorAfterGA.ConditionParameter.ActualName = deletionOperatorAfterGA.HasToBeDeletedVariableName;
+      deletionSelectorAfterGA.CopySelected = new BoolValue(false);
       #endregion
 
@@ -193,16 +302,33 @@
       variableCreator.Successor = initialPopulationConditionalBranch;
       initialPopulationConditionalBranch.TrueBranch = initialSolutionsCreator;
+      initialSolutionsCreator.Successor = initialPopulationSizeAssigner;
       initialPopulationConditionalBranch.FalseBranch = new EmptyOperator();
       initialPopulationConditionalBranch.Successor = classifierFetcher;
       classifierFetcher.Successor = matchCondtionSubScopesProcessor;
+      matchCondtionSubScopesProcessor.Operator = matchConditionOperator;
       matchCondtionSubScopesProcessor.Successor = conditionMatchSelector;
-      //variableCreator.Successor = adaptedGeneticAlgorithmMainLoop;
-      //adaptedGeneticAlgorithmMainLoop.Successor = conditionMatchSelector;
-
       conditionMatchSelector.Successor = matchSetSubScopesProcessor;
       matchSetSubScopesProcessor.Operators.Add(new EmptyOperator());
       matchSetSubScopesProcessor.Operators.Add(countNumberOfUniqueActions);
-      matchSetSubScopesProcessor.Successor = mergingReducerWithSuccessor;
-      countNumberOfUniqueActions.Successor = covering;
+      matchSetSubScopesProcessor.Successor = subscopeVariableCopier;
+      subscopeVariableCopier.Successor = doDeletionBeforeCovering;
+      doDeletionBeforeCovering.Successor = doDeletionBeforeCoveringConditionalBranch;
+      doDeletionBeforeCoveringConditionalBranch.TrueBranch = matchSetMergingReducerForDeletion;
+      matchSetMergingReducerForDeletion.Successor = deletionOperator;
+      deletionOperator.Successor = deletionSelector;
+      deletionSelector.Successor = leftReducerAfterDeletionSelection;
+      leftReducerAfterDeletionSelection.Successor = matchConditionAfterDeletionSubScopesProcessor;
+      doDeletionBeforeCoveringConditionalBranch.FalseBranch = coveringAfterDeletionSubScopesProcessor;
+      coveringAfterDeletionSubScopesProcessor.Operators.Add(new EmptyOperator());
+      coveringAfterDeletionSubScopesProcessor.Operators.Add(covering);
+      coveringAfterDeletionSubScopesProcessor.Successor = matchSetMergingReducer;
+      matchConditionAfterDeletionSubScopesProcessor.Operator = matchConditionOperator;
+      matchConditionAfterDeletionSubScopesProcessor.Successor = conditionMatchSelectorAfterDeletion;
+      conditionMatchSelectorAfterDeletion.Successor = matchSetAfterDeletionSubScopesProcessor;
+      matchSetAfterDeletionSubScopesProcessor.Operators.Add(new EmptyOperator());
+      matchSetAfterDeletionSubScopesProcessor.Operators.Add(countNumberOfUniqueActionsAfterDeletion);
+      matchSetAfterDeletionSubScopesProcessor.Successor = matchSetMergingReducer;
+      countNumberOfUniqueActionsAfterDeletion.Successor = covering;
+
       covering.Successor = predictionArrayCalculator;
       predictionArrayCalculator.Successor = actionSelector;
@@ -218,10 +344,25 @@
       sumAccuracy.Successor = updateParametersSubScopesProcessor;
       updateParametersSubScopesProcessor.Operator = evaluator;
-
-      actionSetSubScopesProcessor.Successor = mergingReducer;
-
-      mergingReducerWithSuccessor.Successor = iterationCounter;
+      updateParametersSubScopesProcessor.Successor = actionSetSubsumptionBranch;
+      actionSetSubsumptionBranch.TrueBranch = actionSetSubsumption;
+      actionSetSubsumption.Successor = subsumptionSelector;
+      subsumptionSelector.Successor = leftReducer;
+      actionSetSubsumptionBranch.FalseBranch = new EmptyOperator();
+      actionSetSubsumptionBranch.Successor = checkIfGAShouldRun;
+      checkIfGAShouldRun.Successor = runGAConditionalBranch;
+      runGAConditionalBranch.TrueBranch = timestampAssignerSubscopeProcessor;
+      runGAConditionalBranch.FalseBranch = new EmptyOperator();
+      timestampAssignerSubscopeProcessor.Operator = timestampAssigner;
+      timestampAssignerSubscopeProcessor.Successor = adaptedGeneticAlgorithmMainLoop;
+      adaptedGeneticAlgorithmMainLoop.Successor = currentPopulationSizeCounter;
+
+      actionSetSubScopesProcessor.Successor = actionSetMergingReducer;
+
+      matchSetMergingReducer.Successor = calculateNumberOfDeletions;
+      calculateNumberOfDeletions.Successor = deletionOperatorAfterGA;
+      deletionOperatorAfterGA.Successor = deletionSelectorAfterGA;
+      deletionSelectorAfterGA.Successor = leftReducerAfterGA;
+      leftReducerAfterGA.Successor = iterationCounter;
       iterationCounter.Successor = classifierFetcher;
-      //mergingReducer.Successor = adaptedGeneticAlgorithmMainLoop;
       #endregion
     }
@@ -249,5 +390,17 @@
       actionExecuter.OperatorParameter.ActualName = problem.ActionExecuterParameter.Name;
 
+      problem.ActionSetSubsumptionOperator.ThetaSubsumptionParameter.ActualName = "ThetaSubsumption";
+      problem.ActionSetSubsumptionOperator.ErrorsParameter.ActualName = "Error";
+      problem.ActionSetSubsumptionOperator.ErrorZeroParameter.ActualName = "ErrorZero";
+      problem.ActionSetSubsumptionOperator.ExperiencesParameter.ActualName = "Experience";
+      problem.ActionSetSubsumptionOperator.NumerositiesParameter.ActualName = "Numerosity";
+
+      subsumptionSelector.ConditionParameter.ActualName = problem.ActionSetSubsumptionOperator.HasBeenSubsumedParameterName;
+
+      actionSetSubsumption.OperatorParameter.ActualName = problem.ActionSetSubsumptionOperatorParameter.Name;
+
       matchConditionOperator.TargetMatchParameter.ActualName = problem.ClassifierFetcher.CurrentClassifierToMatchParameter.ActualName;
+
+      doDeletionBeforeCovering.MinimalNumberOfUniqueActionsParameter.ActualName = problem.ThetaMinimalNumberOfActionsParameter.Name;
 
       covering.SolutionCreatorParameter.ActualName = problem.CoveringSolutionCreatorParameter.Name;
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/CombinedIntegerVector.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/CombinedIntegerVector.cs	(revision 9090)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/CombinedIntegerVector.cs	(revision 9105)
@@ -48,4 +48,6 @@
     public IntMatrix Bounds { get { return (IntMatrix)bounds.Clone(); } }
 
+    public int ConditionLength { get { return Length - actionLength; } }
+
     [StorableConstructor]
     protected CombinedIntegerVector(bool deserializing) : base(deserializing) { }
@@ -184,4 +186,31 @@
     }
 
+    public bool IsMoreGeneral(IClassifier target) {
+      var targetVector = target as CombinedIntegerVector;
+      int curbounds;
+
+      if (this.NumberOfGeneralSymbols() <= targetVector.NumberOfGeneralSymbols()) return false;
+
+      for (int i = 0; i < ConditionLength; i++) {
+        curbounds = i % bounds.Rows;
+        if (this[i] != bounds[curbounds, 1] - 1 && this[i] != targetVector[i]) {
+          return false;
+        }
+      }
+      return true;
+    }
+
+    private int NumberOfGeneralSymbols() {
+      int numberOfGeneralSymbols = 0;
+      int curbounds;
+
+      for (int i = 0; i < ConditionLength; i++) {
+        curbounds = i % bounds.Rows;
+        numberOfGeneralSymbols += this[i] == bounds[curbounds, 1] - 1 ? 1 : 0;
+      }
+
+      return numberOfGeneralSymbols;
+    }
+
     public override string ToString() {
       StringBuilder strBuilder = new StringBuilder(this.Length);
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/HeuristicLab.Encodings.CombinedIntegerVectorEncoding-3.3.csproj
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/HeuristicLab.Encodings.CombinedIntegerVectorEncoding-3.3.csproj	(revision 9090)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/HeuristicLab.Encodings.CombinedIntegerVectorEncoding-3.3.csproj	(revision 9105)
@@ -95,4 +95,5 @@
     <Reference Include="System" />
     <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
     <Reference Include="System.Xml.Linq" />
     <Reference Include="System.Data.DataSetExtensions" />
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/CoveringOperator.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/CoveringOperator.cs	(revision 9090)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/CoveringOperator.cs	(revision 9105)
@@ -53,4 +53,7 @@
       get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
     }
+    public ILookupParameter<IntValue> CurrentPopulationSizeParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["CurrentPopulationSize"]; }
+    }
     public IValueLookupParameter<BoolValue> ParallelParameter {
       get { return (IValueLookupParameter<BoolValue>)Parameters["Parallel"]; }
@@ -83,4 +86,5 @@
       Parameters.Add(new ValueLookupParameter<BoolValue>("Parallel", "True if the operator should be applied in parallel on all sub-scopes, otherwise false.", new BoolValue(true)));
       Parameters.Add(new ScopeParameter("CurrentScope", "The current scope to which the new solutions are added as sub-scopes."));
+      Parameters.Add(new LookupParameter<IntValue>("CurrentPopulationSize"));
     }
 
@@ -97,4 +101,6 @@
         throw new ArgumentException("More classifiers with unique actions shall be created than unique actions are available.");
       }
+
+      CurrentPopulationSizeParameter.ActualValue.Value += count;
 
       int current = CurrentScope.SubScopes.Count;
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/DoDeletionBeforeCovering.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/DoDeletionBeforeCovering.cs	(revision 9105)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/DoDeletionBeforeCovering.cs	(revision 9105)
@@ -0,0 +1,87 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.ConditionActionEncoding {
+  [Item("DoDeletionBeforeCoveringOperator", "Description missing")]
+  [StorableClass]
+  public class DoDeletionBeforeCoveringOperator : SingleSuccessorOperator {
+
+    #region Parameter Properties
+    public ILookupParameter<IntValue> MinimalNumberOfUniqueActionsParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["MinimalNumberOfUniqueActions"]; }
+    }
+    public ILookupParameter<IntValue> NumberOfUniqueActionsParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["NumberOfUniqueActions"]; }
+    }
+    public ILookupParameter<IntValue> CurrentPopulationSizeParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["CurrentPopulationSize"]; }
+    }
+    public ILookupParameter<IntValue> PopulationSizeParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["PopulationSize"]; }
+    }
+    public IValueLookupParameter<BoolValue> DoDeletionParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["DoDeletion"]; }
+    }
+    public IValueLookupParameter<IntValue> NumberToDeleteParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["NumberToDelete"]; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected DoDeletionBeforeCoveringOperator(bool deserializing) : base(deserializing) { }
+    protected DoDeletionBeforeCoveringOperator(DoDeletionBeforeCoveringOperator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public DoDeletionBeforeCoveringOperator()
+      : base() {
+      Parameters.Add(new LookupParameter<IntValue>("MinimalNumberOfUniqueActions"));
+      Parameters.Add(new LookupParameter<IntValue>("NumberOfUniqueActions"));
+      Parameters.Add(new LookupParameter<IntValue>("CurrentPopulationSize"));
+      Parameters.Add(new LookupParameter<IntValue>("PopulationSize"));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("DoDeletion"));
+      Parameters.Add(new ValueLookupParameter<IntValue>("NumberToDelete"));
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DoDeletionBeforeCoveringOperator(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      int populationAfterCovering = MinimalNumberOfUniqueActionsParameter.ActualValue.Value
+                                    - NumberOfUniqueActionsParameter.ActualValue.Value
+                                    + CurrentPopulationSizeParameter.ActualValue.Value;
+      BoolValue doDeletion = new BoolValue(populationAfterCovering > PopulationSizeParameter.ActualValue.Value);
+      if (doDeletion.Value) {
+        NumberToDeleteParameter.ActualValue = new IntValue(populationAfterCovering - PopulationSizeParameter.ActualValue.Value);
+      } else {
+        NumberToDeleteParameter.ActualValue = new IntValue(0);
+      }
+      DoDeletionParameter.ActualValue = doDeletion;
+      return base.Apply();
+    }
+  }
+}
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/ICovering.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/ICovering.cs	(revision 9090)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/ICovering.cs	(revision 9105)
@@ -33,4 +33,6 @@
     IValueLookupParameter<ICoveringSolutionCreator> SolutionCreatorParameter { get; }
     IValueLookupParameter<BoolValue> ParallelParameter { get; }
+
+    ILookupParameter<IntValue> CurrentPopulationSizeParameter { get; }
   }
 }
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Deletion/CalculateNumberOfDeletionsOperator.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Deletion/CalculateNumberOfDeletionsOperator.cs	(revision 9105)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Deletion/CalculateNumberOfDeletionsOperator.cs	(revision 9105)
@@ -0,0 +1,71 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.ConditionActionEncoding {
+  [Item("CalculateNumberOfDeletionsOperator", "Description missing")]
+  [StorableClass]
+  public class CalculateNumberOfDeletionsOperator : SingleSuccessorOperator {
+
+    #region Parameter Properties
+    public ILookupParameter<IntValue> PopulationSizeParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["PopulationSize"]; }
+    }
+    public ILookupParameter<IntValue> CurrentPopulationSizeParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["CurrentPopulationSize"]; }
+    }
+    public IValueLookupParameter<IntValue> NumberOfDeletionsParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["NumberOfDeletions"]; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected CalculateNumberOfDeletionsOperator(bool deserializing) : base(deserializing) { }
+    protected CalculateNumberOfDeletionsOperator(CalculateNumberOfDeletionsOperator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public CalculateNumberOfDeletionsOperator()
+      : base() {
+      Parameters.Add(new LookupParameter<IntValue>("CurrentPopulationSize"));
+      Parameters.Add(new LookupParameter<IntValue>("PopulationSize"));
+      Parameters.Add(new ValueLookupParameter<IntValue>("NumberOfDeletions"));
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new CalculateNumberOfDeletionsOperator(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      int numberOfDeletions = CurrentPopulationSizeParameter.ActualValue.Value - PopulationSizeParameter.ActualValue.Value;
+      if (numberOfDeletions > 0) {
+        NumberOfDeletionsParameter.ActualValue = new IntValue(numberOfDeletions);
+      } else {
+        NumberOfDeletionsParameter.ActualValue = new IntValue(0);
+      }
+      return base.Apply();
+    }
+  }
+}
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Deletion/XCSDeletionOperator.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Deletion/XCSDeletionOperator.cs	(revision 9105)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Deletion/XCSDeletionOperator.cs	(revision 9105)
@@ -0,0 +1,161 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.ConditionActionEncoding {
+  [Item("XCSDeletionOperator", "Description missing")]
+  [StorableClass]
+  public class XCSDeletionOperator : SingleSuccessorOperator, IStochasticOperator {
+
+    #region Parameter Properties
+    public ILookupParameter<IntValue> NumberToDeleteParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["NumberToDelete"]; }
+    }
+    public ILookupParameter<ItemArray<IntValue>> NumerositiesParameter {
+      get { return (ILookupParameter<ItemArray<IntValue>>)Parameters["Numerosities"]; }
+    }
+    public ILookupParameter<ItemArray<DoubleValue>> AverageActionSetSizesParameter {
+      get { return (ILookupParameter<ItemArray<DoubleValue>>)Parameters["AverageActionSetSizes"]; }
+    }
+    public ILookupParameter<ItemArray<DoubleValue>> FitnessesParameter {
+      get { return (ILookupParameter<ItemArray<DoubleValue>>)Parameters["Fitnesses"]; }
+    }
+    public ILookupParameter<ItemArray<IntValue>> ExperiencesParameter {
+      get { return (ILookupParameter<ItemArray<IntValue>>)Parameters["Experiences"]; }
+    }
+    public ILookupParameter<IntValue> ThetaDeletionParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["ThetaDeletion"]; }
+    }
+    public ILookupParameter<PercentValue> DeltaParameter {
+      get { return (ILookupParameter<PercentValue>)Parameters["Delta"]; }
+    }
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<IntValue> CurrentPopulationSizeParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["CurrentPopulationSize"]; }
+    }
+    protected ScopeParameter CurrentScopeParameter {
+      get { return (ScopeParameter)Parameters["CurrentScope"]; }
+    }
+    public IScope CurrentScope {
+      get { return CurrentScopeParameter.ActualValue; }
+    }
+    public string HasToBeDeletedVariableName { get { return "HasToBeDeleted"; } }
+    #endregion
+
+    #region Parameter Properties
+    private double Delta { get { return DeltaParameter.ActualValue.Value; } }
+    private int ThetaDeletion { get { return ThetaDeletionParameter.ActualValue.Value; } }
+    #endregion
+
+    [StorableConstructor]
+    protected XCSDeletionOperator(bool deserializing) : base(deserializing) { }
+    protected XCSDeletionOperator(XCSDeletionOperator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public XCSDeletionOperator()
+      : base() {
+      Parameters.Add(new LookupParameter<IntValue>("NumberToDelete"));
+      Parameters.Add(new ScopeTreeLookupParameter<IntValue>("Numerosities"));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("AverageActionSetSizes"));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Fitnesses"));
+      Parameters.Add(new ScopeTreeLookupParameter<IntValue>("Experiences"));
+      Parameters.Add(new LookupParameter<IntValue>("ThetaDeletion"));
+      Parameters.Add(new LookupParameter<PercentValue>("Delta"));
+      Parameters.Add(new LookupParameter<IRandom>("Random"));
+      Parameters.Add(new ScopeParameter("CurrentScope"));
+      Parameters.Add(new LookupParameter<IntValue>("CurrentPopulationSize"));
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new XCSDeletionOperator(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      var fitnesses = FitnessesParameter.ActualValue;
+      var numerosities = NumerositiesParameter.ActualValue;
+      var experiences = ExperiencesParameter.ActualValue;
+      var averageActionSetSizes = AverageActionSetSizesParameter.ActualValue;
+      var subscopes = CurrentScope.SubScopes;
+      double fitnessSum = fitnesses.Select(x => x.Value).Sum();
+      double numerositySum = numerosities.Select(x => x.Value).Sum();
+
+      if (fitnesses.Length != numerosities.Length && fitnesses.Length != experiences.Length && fitnesses.Length != subscopes.Count) {
+        throw new ArgumentException("Different number of fitness, numerosity and experience values.");
+      }
+
+      for (int cl = 0; cl < fitnesses.Length; cl++) {
+        if (subscopes[cl].Variables.ContainsKey(HasToBeDeletedVariableName)) {
+          ((BoolValue)subscopes[cl].Variables[HasToBeDeletedVariableName].Value).Value = false;
+        } else {
+          subscopes[cl].Variables.Add(new Variable(HasToBeDeletedVariableName, new BoolValue(false)));
+        }
+      }
+
+      for (int i = 0; i < NumberToDeleteParameter.ActualValue.Value; i++) {
+        double voteSum = 0;
+        double averageFitnessInPopulation = fitnessSum / numerositySum;
+        for (int cl = 0; cl < fitnesses.Length; cl++) {
+          if (numerosities[cl].Value > 0) {
+            voteSum += DeletionVote(averageFitnessInPopulation, averageActionSetSizes[cl].Value, numerosities[cl].Value, fitnesses[cl].Value, experiences[cl].Value);
+          }
+        }
+        double choicePoint = RandomParameter.ActualValue.NextDouble() * voteSum;
+        voteSum = 0;
+        for (int cl = 0; cl < fitnesses.Length; cl++) {
+          if (numerosities[cl].Value > 0) {
+            voteSum += DeletionVote(averageFitnessInPopulation, averageActionSetSizes[cl].Value, numerosities[cl].Value, fitnesses[cl].Value, experiences[cl].Value);
+            if (voteSum > choicePoint) {
+              if (numerosities[cl].Value <= 1) {
+                ((BoolValue)subscopes[cl].Variables[HasToBeDeletedVariableName].Value).Value = true;
+                fitnessSum -= fitnesses[cl].Value;
+              }
+              numerosities[cl].Value--;
+              numerositySum--;
+              break;
+            }
+          }
+        }
+      }
+
+      CurrentPopulationSizeParameter.ActualValue.Value -= NumberToDeleteParameter.ActualValue.Value;
+
+      return base.Apply();
+    }
+
+    private double DeletionVote(double averageFitnessInPopulation, double ass, int num, double f, int exp) {
+      double vote = ass * num;
+      if (exp > ThetaDeletion && (f / num) < Delta * averageFitnessInPopulation) {
+        vote *= averageFitnessInPopulation / (f / num);
+      }
+      return vote;
+    }
+  }
+}
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/GA/XCSAfterCrossoverOperator.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/GA/XCSAfterCrossoverOperator.cs	(revision 9105)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/GA/XCSAfterCrossoverOperator.cs	(revision 9105)
@@ -0,0 +1,113 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.ConditionActionEncoding {
+  [Item("XCSAfterCrossoverOperator", "Description missing")]
+  [StorableClass]
+  public class XCSAfterCrossoverOperator : SingleSuccessorOperator {
+
+    #region Parameter Properties
+    public IValueLookupParameter<IntValue> NumerosityParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["Numerosity"]; }
+    }
+    public IValueLookupParameter<IntValue> ExperienceParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["Experience"]; }
+    }
+    public IValueLookupParameter<IntValue> TimestampParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["Timestamp"]; }
+    }
+    public IValueLookupParameter<DoubleValue> PredictionParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["Prediction"]; }
+    }
+    public IValueLookupParameter<DoubleValue> AverageActionSetSizeParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["AverageActionSetSize"]; }
+    }
+    public IValueLookupParameter<DoubleValue> ErrorParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["Error"]; }
+    }
+    public IValueLookupParameter<DoubleValue> FitnessParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["Fitness"]; }
+    }
+    public ILookupParameter<IntValue> CurrentIterationParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["CurrentIteration"]; }
+    }
+    public ILookupParameter<ItemArray<DoubleValue>> ParentAverageActionSetSizeParameter {
+      get { return (ILookupParameter<ItemArray<DoubleValue>>)Parameters["ParentAverageActionSetSize"]; }
+    }
+    public ILookupParameter<ItemArray<DoubleValue>> ParentPredictionParameter {
+      get { return (ILookupParameter<ItemArray<DoubleValue>>)Parameters["ParentPrediction"]; }
+    }
+    public ILookupParameter<ItemArray<DoubleValue>> ParentErrorParameter {
+      get { return (ILookupParameter<ItemArray<DoubleValue>>)Parameters["ParentError"]; }
+    }
+    public ILookupParameter<ItemArray<DoubleValue>> ParentFitnessParameter {
+      get { return (ILookupParameter<ItemArray<DoubleValue>>)Parameters["ParentFitness"]; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected XCSAfterCrossoverOperator(bool deserializing) : base(deserializing) { }
+    protected XCSAfterCrossoverOperator(XCSAfterCrossoverOperator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public XCSAfterCrossoverOperator()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<IntValue>("Numerosity"));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Experience"));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Timestamp"));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("AverageActionSetSize"));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Prediction"));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Error"));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Fitness"));
+      Parameters.Add(new LookupParameter<IntValue>("CurrentIteration"));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("ParentAverageActionSetSize"));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("ParentPrediction"));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("ParentError"));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("ParentFitness"));
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new XCSAfterCrossoverOperator(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      NumerosityParameter.ActualValue = new IntValue(1);
+      ExperienceParameter.ActualValue = new IntValue(0);
+      TimestampParameter.ActualValue = new IntValue(CurrentIterationParameter.ActualValue.Value);
+      var parentAverageActionSetSize = ParentAverageActionSetSizeParameter.ActualValue;
+      var parentPrecision = ParentPredictionParameter.ActualValue;
+      var parentPrecisionError = ParentErrorParameter.ActualValue;
+      var parentFitness = ParentFitnessParameter.ActualValue;
+      AverageActionSetSizeParameter.ActualValue = new DoubleValue(parentAverageActionSetSize.Select(x => x.Value).Average());
+      PredictionParameter.ActualValue = new DoubleValue(parentPrecision.Select(x => x.Value).Average());
+      ErrorParameter.ActualValue = new DoubleValue(0.25 * parentPrecisionError.Select(x => x.Value).Average());
+      FitnessParameter.ActualValue = new DoubleValue(0.1 * parentFitness.Select(x => x.Value).Average());
+      return base.Apply();
+    }
+  }
+}
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/GA/XCSCheckIfGAShouldBeApplied.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/GA/XCSCheckIfGAShouldBeApplied.cs	(revision 9105)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/GA/XCSCheckIfGAShouldBeApplied.cs	(revision 9105)
@@ -0,0 +1,93 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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 HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.ConditionActionEncoding {
+  [Item("CheckIfGAShouldBeApplied", "Description missing")]
+  [StorableClass]
+  public class XCSCheckIfGAShouldBeApplied : SingleSuccessorOperator {
+
+    #region Parameter Properties
+    public ILookupParameter<IntValue> ThetaGAParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["ThetaGA"]; }
+    }
+    public ILookupParameter<IntValue> IterationParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["Iteration"]; }
+    }
+    public ILookupParameter<ItemArray<IntValue>> TimeStampsParameter {
+      get { return (ILookupParameter<ItemArray<IntValue>>)Parameters["TimeStamps"]; }
+    }
+    public ILookupParameter<ItemArray<IntValue>> NumerositiesParameter {
+      get { return (ILookupParameter<ItemArray<IntValue>>)Parameters["Numerosities"]; }
+    }
+    public IValueLookupParameter<BoolValue> RunGAParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["RunGA"]; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected XCSCheckIfGAShouldBeApplied(bool deserializing) : base(deserializing) { }
+    protected XCSCheckIfGAShouldBeApplied(XCSCheckIfGAShouldBeApplied original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public XCSCheckIfGAShouldBeApplied()
+      : base() {
+      Parameters.Add(new LookupParameter<IntValue>("ThetaGA"));
+      Parameters.Add(new LookupParameter<IntValue>("Iteration"));
+      Parameters.Add(new ScopeTreeLookupParameter<IntValue>("TimeStamps"));
+      Parameters.Add(new ScopeTreeLookupParameter<IntValue>("Numerosities"));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("RunGA"));
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new XCSCheckIfGAShouldBeApplied(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      int numerositySum = 0;
+      int timestamNumerositySum = 0;
+
+      var timestamps = TimeStampsParameter.ActualValue;
+      var numerosities = NumerositiesParameter.ActualValue;
+      int actualtime = IterationParameter.ActualValue.Value;
+      int thetaGA = ThetaGAParameter.ActualValue.Value;
+
+      if (timestamps.Length != numerosities.Length) {
+        throw new ArgumentException("The number of timestamps and numerosities is not the same.");
+      }
+
+      for (int i = 0; i < numerosities.Length; i++) {
+        numerositySum += numerosities[i].Value;
+        timestamNumerositySum += timestamps[i].Value * numerosities[i].Value;
+      }
+
+      RunGAParameter.ActualValue = new BoolValue(actualtime - (timestamNumerositySum / numerositySum) > thetaGA);
+
+      return base.Apply();
+    }
+  }
+}
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/HeuristicLab.Encodings.ConditionActionEncoding-3.3.csproj
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/HeuristicLab.Encodings.ConditionActionEncoding-3.3.csproj	(revision 9090)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/HeuristicLab.Encodings.ConditionActionEncoding-3.3.csproj	(revision 9105)
@@ -71,4 +71,5 @@
     <Reference Include="System" />
     <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
     <Reference Include="System.Xml.Linq" />
     <Reference Include="System.Data.DataSetExtensions" />
@@ -83,17 +84,23 @@
     <Compile Include="ActionSelection\RandomActionSelector.cs" />
     <Compile Include="Covering\CoveringOperator.cs" />
+    <Compile Include="Covering\DoDeletionBeforeCovering.cs" />
     <Compile Include="Covering\ICovering.cs" />
     <Compile Include="Covering\ICoveringSolutionCreator.cs" />
+    <Compile Include="Deletion\CalculateNumberOfDeletionsOperator.cs" />
+    <Compile Include="Deletion\XCSDeletionOperator.cs" />
     <Compile Include="Evaluators\XCSEvaluator.cs" />
     <Compile Include="Evaluators\IConditionActionEvaluator.cs" />
     <Compile Include="Evaluators\IXCSEvaluator.cs" />
+    <Compile Include="GA\XCSAfterCrossoverOperator.cs" />
     <Compile Include="IClassifier.cs" />
     <Compile Include="Interfaces\IConditionActionProblem.cs" />
     <Compile Include="Interfaces\IConditionActionProblemData.cs" />
     <Compile Include="Operator\CalculateAccuracy.cs" />
+    <Compile Include="GA\XCSCheckIfGAShouldBeApplied.cs" />
     <Compile Include="Operator\CountNumberOfUniqueActions.cs" />
     <Compile Include="Operator\PredictionArrayCalculator.cs" />
     <Compile Include="Operator\MatchActionOperator.cs" />
     <Compile Include="Operator\MatchConditionOperator.cs" />
+    <Compile Include="Operator\SubScopeVariableCopier.cs" />
     <Compile Include="Operator\SumAccuracy.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
@@ -104,4 +111,6 @@
     <Compile Include="Selectors\IMatchSelector.cs" />
     <Compile Include="Selectors\MatchSelector.cs" />
+    <Compile Include="Subsumption\ActionSetSubsumptionoperator.cs" />
+    <Compile Include="Subsumption\IActionSetSubsumption.cs" />
     <None Include="Properties\AssemblyInfo.cs.frame" />
   </ItemGroup>
@@ -112,4 +121,13 @@
   <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>
   <!-- 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/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/IClassifier.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/IClassifier.cs	(revision 9090)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/IClassifier.cs	(revision 9105)
@@ -35,4 +35,5 @@
     bool MatchCondition(IClassifier target);
     bool MatchAction(IClassifier target);
+    bool IsMoreGeneral(IClassifier target);
 
     //to use IMatching as key in a dictionary, Equals and GetHashCode have to be override. 
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionProblem.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionProblem.cs	(revision 9090)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionProblem.cs	(revision 9105)
@@ -39,4 +39,7 @@
     IParameter CoveringSolutionCreatorParameter { get; }
 
+    IParameter ActionSetSubsumptionOperatorParameter { get; }
+    IActionSetSubsumption ActionSetSubsumptionOperator { get; }
+
     new IXCSEvaluator Evaluator { get; }
   }
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/SubScopeVariableCopier.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/SubScopeVariableCopier.cs	(revision 9105)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/SubScopeVariableCopier.cs	(revision 9105)
@@ -0,0 +1,72 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.ConditionActionEncoding {
+  [Item("SubScopeVariableCopier", "Description missing")]
+  [StorableClass]
+  public class SubScopeVariableCopier : SingleSuccessorOperator {
+
+    #region Parameter Properties
+    public IValueLookupParameter<IntValue> SubScopeIndexParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["SubScopeIndex"]; }
+    }
+    private ScopeParameter CurrentScopeParameter {
+      get { return (ScopeParameter)Parameters["CurrentScope"]; }
+    }
+    public IScope CurrentScope {
+      get { return CurrentScopeParameter.ActualValue; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected SubScopeVariableCopier(bool deserializing) : base(deserializing) { }
+    protected SubScopeVariableCopier(SubScopeVariableCopier original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public SubScopeVariableCopier()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<IntValue>("SubScopeIndex"));
+      Parameters.Add(new ScopeParameter("CurrentScope"));
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SubScopeVariableCopier(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      IScope subscope = CurrentScope.SubScopes[SubScopeIndexParameter.ActualValue.Value];
+      foreach (var variable in subscope.Variables) {
+        if (CurrentScope.Variables.ContainsKey(variable.Name)) {
+          CurrentScope.Variables[variable.Name].Value = variable.Value;
+        } else {
+          CurrentScope.Variables.Add((Variable)variable.Clone());
+        }
+      }
+      return base.Apply();
+    }
+  }
+}
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Subsumption/ActionSetSubsumptionoperator.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Subsumption/ActionSetSubsumptionoperator.cs	(revision 9105)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Subsumption/ActionSetSubsumptionoperator.cs	(revision 9105)
@@ -0,0 +1,136 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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 HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.ConditionActionEncoding {
+  [Item("ActionSetSubsumptionoperator", "Description missing")]
+  [StorableClass]
+  public class ActionSetSubsumptionoperator : SingleSuccessorOperator, IActionSetSubsumption {
+
+    #region Parameter Properties
+    public ILookupParameter<ItemArray<IClassifier>> ClassifiersParameter {
+      get { return (ILookupParameter<ItemArray<IClassifier>>)Parameters["Classifiers"]; }
+    }
+    public ILookupParameter<ItemArray<IntValue>> NumerositiesParameter {
+      get { return (ILookupParameter<ItemArray<IntValue>>)Parameters["Numerosities"]; }
+    }
+    public ILookupParameter<ItemArray<IntValue>> ExperiencesParameter {
+      get { return (ILookupParameter<ItemArray<IntValue>>)Parameters["Experiences"]; }
+    }
+    public ILookupParameter<ItemArray<DoubleValue>> ErrorsParameter {
+      get { return (ILookupParameter<ItemArray<DoubleValue>>)Parameters["Errors"]; }
+    }
+    public ILookupParameter<DoubleValue> ErrorZeroParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["ErrorZero"]; }
+    }
+    public ILookupParameter<IntValue> ThetaSubsumptionParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["ThetaSubsumption"]; }
+    }
+    protected ScopeParameter CurrentScopeParameter {
+      get { return (ScopeParameter)Parameters["CurrentScope"]; }
+    }
+    public IScope CurrentScope {
+      get { return CurrentScopeParameter.ActualValue; }
+    }
+
+    public string HasBeenSubsumedParameterName {
+      get { return "HasBeenSubsumed"; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected ActionSetSubsumptionoperator(bool deserializing) : base(deserializing) { }
+    protected ActionSetSubsumptionoperator(ActionSetSubsumptionoperator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public ActionSetSubsumptionoperator()
+      : base() {
+      Parameters.Add(new ScopeTreeLookupParameter<IClassifier>("Classifiers"));
+      Parameters.Add(new ScopeTreeLookupParameter<IntValue>("Numerosities"));
+      Parameters.Add(new ScopeTreeLookupParameter<IntValue>("Experiences"));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Errors"));
+      Parameters.Add(new LookupParameter<DoubleValue>("ErrorZero"));
+      Parameters.Add(new LookupParameter<IntValue>("ThetaSubsumption"));
+      Parameters.Add(new ScopeParameter("CurrentScope"));
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ActionSetSubsumptionoperator(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      var subscopes = CurrentScope.SubScopes;
+      var classifiers = ClassifiersParameter.ActualValue;
+      var numerosities = NumerositiesParameter.ActualValue;
+      var experiences = ExperiencesParameter.ActualValue;
+      var errors = ErrorsParameter.ActualValue;
+      if (subscopes.Count != classifiers.Length || subscopes.Count != numerosities.Length
+        || subscopes.Count != experiences.Length || subscopes.Count != errors.Length) {
+        throw new ArgumentException("The number of subscopes is not equal to the number of classifiers.");
+      }
+
+      int subsumptionClassifier = -1;
+
+      for (int i = 0; i < classifiers.Length; i++) {
+        if (CouldSubsume(experiences[i], errors[i])) {
+          if (subsumptionClassifier == -1 || classifiers[i].IsMoreGeneral(classifiers[subsumptionClassifier])) {
+            subsumptionClassifier = i;
+          }
+        }
+      }
+
+      if (subsumptionClassifier != -1) {
+        for (int i = 0; i < classifiers.Length; i++) {
+          if (classifiers[subsumptionClassifier].IsMoreGeneral(classifiers[i])) {
+            numerosities[subsumptionClassifier].Value += numerosities[i].Value;
+            AddVariableToScope(subscopes[i], new BoolValue(true));
+          } else {
+            AddVariableToScope(subscopes[i], new BoolValue(false));
+          }
+        }
+      } else {
+        for (int i = 0; i < classifiers.Length; i++) {
+          AddVariableToScope(subscopes[i], new BoolValue(false));
+        }
+      }
+
+      return base.Apply();
+    }
+
+    private void AddVariableToScope(IScope scope, BoolValue boolValue) {
+      if (scope.Variables.ContainsKey(HasBeenSubsumedParameterName)) {
+        scope.Variables[HasBeenSubsumedParameterName].Value = boolValue;
+      } else {
+        scope.Variables.Add(new Variable(HasBeenSubsumedParameterName, boolValue));
+      }
+    }
+
+    private bool CouldSubsume(IntValue exp, DoubleValue error) {
+      return exp.Value > ThetaSubsumptionParameter.ActualValue.Value && error.Value < ErrorZeroParameter.ActualValue.Value;
+    }
+  }
+}
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Subsumption/IActionSetSubsumption.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Subsumption/IActionSetSubsumption.cs	(revision 9105)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Subsumption/IActionSetSubsumption.cs	(revision 9105)
@@ -0,0 +1,38 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 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 HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.Encodings.ConditionActionEncoding {
+  public interface IActionSetSubsumption : IOperator, IParameterizedNamedItem, INamedItem, IParameterizedItem, IItem, IContent, IDeepCloneable, ICloneable {
+    ILookupParameter<ItemArray<IClassifier>> ClassifiersParameter { get; }
+    ILookupParameter<ItemArray<IntValue>> NumerositiesParameter { get; }
+    ILookupParameter<ItemArray<IntValue>> ExperiencesParameter { get; }
+    ILookupParameter<ItemArray<DoubleValue>> ErrorsParameter { get; }
+    ILookupParameter<DoubleValue> ErrorZeroParameter { get; }
+    ILookupParameter<IntValue> ThetaSubsumptionParameter { get; }
+
+    string HasBeenSubsumedParameterName { get; }
+  }
+}
Index: branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/HeuristicLab.Problems.ConditionActionClassification-3.3.csproj
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/HeuristicLab.Problems.ConditionActionClassification-3.3.csproj	(revision 9090)
+++ branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/HeuristicLab.Problems.ConditionActionClassification-3.3.csproj	(revision 9105)
@@ -65,4 +65,5 @@
     <Reference Include="System" />
     <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
     <Reference Include="System.Xml.Linq" />
     <Reference Include="System.Data.DataSetExtensions" />
@@ -94,4 +95,13 @@
   </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>
   <!-- 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/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/Implementation/ConditionActionClassificationProblem.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/Implementation/ConditionActionClassificationProblem.cs	(revision 9090)
+++ branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/Implementation/ConditionActionClassificationProblem.cs	(revision 9105)
@@ -36,4 +36,5 @@
     private const string ClassifierFetcherParameterName = "ClassifierFetcher";
     private const string ActionExecuterParameterName = "ActionExecuter";
+    private const string ActionSetSubsumptionOperatorParameterName = "ActionSetSubsumption";
 
     IXCSEvaluator IConditionActionProblem.Evaluator {
@@ -118,4 +119,14 @@
     IClassifierFetcher IConditionActionProblem.ClassifierFetcher { get { return ClassifierFetcher; } }
     IParameter IConditionActionProblem.ClassifierFetcherParameter { get { return ClassifierFetcherParameter; } }
+
+
+    public ActionSetSubsumptionoperator ActionSetSubsumptionOperator {
+      get { return ActionSetSubsumptionOperatorParameter.Value; }
+    }
+    public ValueParameter<ActionSetSubsumptionoperator> ActionSetSubsumptionOperatorParameter {
+      get { return (ValueParameter<ActionSetSubsumptionoperator>)Parameters[ActionSetSubsumptionOperatorParameterName]; }
+    }
+    IActionSetSubsumption IConditionActionProblem.ActionSetSubsumptionOperator { get { return ActionSetSubsumptionOperator; } }
+    IParameter IConditionActionProblem.ActionSetSubsumptionOperatorParameter { get { return ActionSetSubsumptionOperatorParameter; } }
 
     private IntValue ThetaMinimalNumberOfActions {
@@ -164,8 +175,10 @@
       Parameters.Add(new ValueParameter<CombinedIntegerVectorClassifierFetcher>(ClassifierFetcherParameterName, "", new CombinedIntegerVectorClassifierFetcher()));
       Parameters.Add(new FixedValueParameter<ItemSet<IClassifier>>("PossibleActions"));
-      Parameters.Add(new FixedValueParameter<IntValue>("ThetaMinimalNumberOfActions", "Minimal number of actions, which have to be present in the match set, or else covering will occure."));
+      Parameters.Add(new FixedValueParameter<IntValue>("ThetaMinimalNumberOfActions", "Minimal number of actions, which have to be present in the match set, or else covering will occure.", new IntValue(1)));
 
       Parameters.Add(new ValueParameter<ICoveringSolutionCreator>("CoveringSolutionCreator", "", coveringSolutionCreator));
       Parameters.Add(new FixedValueParameter<PercentValue>("ChangeSymbolProbabilityInCovering", "", new PercentValue(0.5)));
+
+      Parameters.Add(new ValueParameter<ActionSetSubsumptionoperator>(ActionSetSubsumptionOperatorParameterName, "", new ActionSetSubsumptionoperator()));
 
       Evaluator.InitialErrorParameter.ActualName = "InitialError";
@@ -188,4 +201,6 @@
       ActionExecuter.NegativeRewardParameter.ActualName = NegativeRewardParameter.Name;
       ActionExecuter.PositiveRewardParameter.ActualName = PositiveRewardParameter.Name;
+
+      ActionSetSubsumptionOperator.ClassifiersParameter.ActualName = "CombinedIntegerVector";
 
       SetPossibleActions();
