Index: /branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LCSAdaptedGeneticAlgorithm.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LCSAdaptedGeneticAlgorithm.cs	(revision 9109)
+++ /branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LCSAdaptedGeneticAlgorithm.cs	(revision 9110)
@@ -24,4 +24,5 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.ConditionActionEncoding;
 using HeuristicLab.Operators;
 using HeuristicLab.Optimization.Operators;
@@ -36,4 +37,8 @@
   [StorableClass]
   public sealed class LCSAdaptedGeneticAlgorithm : AlgorithmOperator {
+    private const string TEMPID = "TempID";
+    private const string SUBSUMEDBY = "SubsumedBy";
+    private const string SUBSUMED = "Subsumed";
+
     #region Parameter properties
     public ValueLookupParameter<IRandom> RandomParameter {
@@ -75,4 +80,7 @@
     public ValueLookupParameter<IntValue> PopulationSizeParameter {
       get { return (ValueLookupParameter<IntValue>)Parameters["PopulationSize"]; }
+    }
+    public ValueLookupParameter<BoolValue> DoGASubsumptionParameter {
+      get { return (ValueLookupParameter<BoolValue>)Parameters["DoGASubsumption"]; }
     }
     private ScopeParameter CurrentScopeParameter {
@@ -113,4 +121,5 @@
       Parameters.Add(new ValueLookupParameter<IntValue>("EvaluatedSolutions", "The number of times solutions have been evaluated."));
       Parameters.Add(new ValueLookupParameter<IntValue>("PopulationSize", "The size of the population."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("DoGASubsumption", "Sets if GA subsumption is executed."));
       Parameters.Add(new ScopeParameter("CurrentScope", "The current scope which represents a population of solutions on which the genetic algorithm should be applied."));
       #endregion
@@ -126,5 +135,4 @@
       Placeholder crossover = new Placeholder();
       Placeholder afterCrossover = new Placeholder();
-      StochasticBranch stochasticBranch = new StochasticBranch();
       Placeholder mutator = new Placeholder();
       SubScopesRemover subScopesRemover = new SubScopesRemover();
@@ -136,4 +144,15 @@
       ConditionalBranch conditionalBranch = new ConditionalBranch();
 
+      TempSubScopeIDAssigner tempIdAssigner = new TempSubScopeIDAssigner();
+      ConditionalBranch doGASubsumptionBranch1 = new ConditionalBranch();
+      UniformSubScopesProcessor setSubsumptionFalseSubScopesProcessor = new UniformSubScopesProcessor();
+      Assigner setSubsumpByAssigner = new Assigner();
+      Assigner setSubsumptionFalseAssigner = new Assigner();
+      CheckGASubsumptionOperator checkGASubsumptionOperator = new CheckGASubsumptionOperator();
+      ConditionalBranch doGASubsumptionBranch2 = new ConditionalBranch();
+      ExecuteGASubsumptionOperator executeGAsubsumptionOperator = new ExecuteGASubsumptionOperator();
+      ConditionalSelector subsumptionSelector = new ConditionalSelector();
+      LeftReducer subsumptionLeftReducer = new LeftReducer();
+
       variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Generations", new IntValue(0))); // Class GeneticAlgorithm expects this to be called Generations
 
@@ -144,4 +163,12 @@
       analyzer1.OperatorParameter.ActualName = "Analyzer";
 
+      tempIdAssigner.LeftSideParameter.ActualName = TEMPID;
+
+      setSubsumpByAssigner.LeftSideParameter.ActualName = SUBSUMEDBY;
+      setSubsumpByAssigner.RightSideParameter.Value = new IntValue(-1);
+
+      setSubsumptionFalseAssigner.LeftSideParameter.ActualName = SUBSUMED;
+      setSubsumptionFalseAssigner.RightSideParameter.Value = new BoolValue(false);
+
       selector.Name = "Selector";
       selector.OperatorParameter.ActualName = "Selector";
@@ -155,11 +182,30 @@
       afterCrossover.OperatorParameter.ActualName = "AfterCrossover";
 
-      stochasticBranch.ProbabilityParameter.ActualName = "MutationProbability";
-      stochasticBranch.RandomParameter.ActualName = "Random";
-
       mutator.Name = "Mutator";
       mutator.OperatorParameter.ActualName = "Mutator";
 
+      doGASubsumptionBranch1.ConditionParameter.ActualName = DoGASubsumptionParameter.ActualName;
+
+      checkGASubsumptionOperator.ChildClassifiersParameter.ActualName = "CombinedIntegerVector";
+      checkGASubsumptionOperator.ParentsClassifiersParameter.ActualName = "CombinedIntegerVector";
+      checkGASubsumptionOperator.NumerositiesParameter.ActualName = "Numerosity";
+      checkGASubsumptionOperator.ExperiencesParameter.ActualName = "Experience";
+      checkGASubsumptionOperator.ErrorsParameter.ActualName = "Error";
+      checkGASubsumptionOperator.TempIDParameter.ActualName = TEMPID;
+      checkGASubsumptionOperator.ErrorZeroParameter.ActualName = "ErrorZero";
+      checkGASubsumptionOperator.ThetaSubsumptionParameter.ActualName = "ThetaSubsumption";
+      checkGASubsumptionOperator.SubsumedByParameter.ActualName = SUBSUMEDBY;
+      checkGASubsumptionOperator.SubsumedParameter.ActualName = SUBSUMED;
+
       subScopesRemover.RemoveAllSubScopes = true;
+
+      doGASubsumptionBranch2.ConditionParameter.ActualName = DoGASubsumptionParameter.ActualName;
+
+      executeGAsubsumptionOperator.NumerositiesParameter.ActualName = "Numerosity";
+      executeGAsubsumptionOperator.TempIDParameter.ActualName = TEMPID;
+      executeGAsubsumptionOperator.SubsumedByParameter.ActualName = SUBSUMEDBY;
+
+      subsumptionSelector.ConditionParameter.ActualName = SUBSUMED;
+      subsumptionSelector.CopySelected = new BoolValue(false);
 
       subScopesCounter.Name = "Increment EvaluatedSolutions";
@@ -184,5 +230,10 @@
       variableCreator.Successor = resultsCollector1;
       resultsCollector1.Successor = analyzer1;
-      analyzer1.Successor = selector;
+      analyzer1.Successor = tempIdAssigner;
+      tempIdAssigner.Successor = setSubsumptionFalseSubScopesProcessor;
+      setSubsumptionFalseSubScopesProcessor.Operator = setSubsumpByAssigner;
+      setSubsumpByAssigner.Successor = setSubsumptionFalseAssigner;
+      setSubsumptionFalseAssigner.Successor = null;
+      setSubsumptionFalseSubScopesProcessor.Successor = selector;
       selector.Successor = subScopesProcessor1;
       subScopesProcessor1.Operators.Add(new EmptyOperator());
@@ -193,12 +244,18 @@
       uniformSubScopesProcessor1.Successor = subScopesCounter;
       crossover.Successor = afterCrossover;
-      afterCrossover.Successor = stochasticBranch;
-      stochasticBranch.FirstBranch = mutator;
-      stochasticBranch.SecondBranch = null;
-      stochasticBranch.Successor = subScopesRemover;
-      mutator.Successor = null;
+      afterCrossover.Successor = mutator;
+      mutator.Successor = doGASubsumptionBranch1;
+      doGASubsumptionBranch1.TrueBranch = checkGASubsumptionOperator;
+      doGASubsumptionBranch1.FalseBranch = new EmptyOperator();
+      doGASubsumptionBranch1.Successor = subScopesRemover;
       subScopesRemover.Successor = null;
       subScopesCounter.Successor = null;
-      mergingReducer.Successor = intCounter;
+      mergingReducer.Successor = doGASubsumptionBranch2;
+      doGASubsumptionBranch2.TrueBranch = executeGAsubsumptionOperator;
+      doGASubsumptionBranch2.FalseBranch = new EmptyOperator();
+      executeGAsubsumptionOperator.Successor = subsumptionSelector;
+      subsumptionSelector.Successor = subsumptionLeftReducer;
+      subsumptionLeftReducer.Successor = null;
+      doGASubsumptionBranch2.Successor = intCounter;
       intCounter.Successor = comparator;
       comparator.Successor = analyzer2;
Index: /branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystemMainLoop.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystemMainLoop.cs	(revision 9109)
+++ /branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystemMainLoop.cs	(revision 9110)
@@ -23,6 +23,6 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.CombinedIntegerVectorEncoding;
 using HeuristicLab.Encodings.ConditionActionEncoding;
-using HeuristicLab.Encodings.IntegerVectorEncoding;
 using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
@@ -39,4 +39,6 @@
   [StorableClass]
   public sealed class LearningClassifierSystemMainLoop : AlgorithmOperator {
+    private const string HASTOBEDELETED = "HasToBeDeleted";
+    private const string HASBEENSUBSUMED = "HasBeenSubsumed";
 
     #region Parameter Properties
@@ -62,5 +64,6 @@
     private DoDeletionBeforeCoveringOperator doDeletionBeforeCovering;
     private CoveringOperator covering;
-    private ConditionalSelector subsumptionSelector;
+
+    private UniformSomePositionManipulator test;
 
     private Placeholder evaluator;
@@ -88,7 +91,8 @@
       Parameters.Add(new ConstrainedValueParameter<ICrossover>("Crossover", "The operator used to cross solutions.", new ItemSet<ICrossover>() { new HeuristicLab.Encodings.CombinedIntegerVectorEncoding.SinglePointCrossover() }, new HeuristicLab.Encodings.CombinedIntegerVectorEncoding.SinglePointCrossover()));
       Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator used to evaluate solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
-      UniformOnePositionManipulator test = new UniformOnePositionManipulator();
-      test.IntegerVectorParameter.ActualName = "CombinedIntegerVector";
-      Parameters.Add(new OptionalConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions.", new ItemSet<IManipulator>() { new UniformOnePositionManipulator() }, test));
+      test = new UniformSomePositionManipulator();
+      test.ProbabilityParameter.ActualName = "MutationProbability";
+      test.ChildParameter.ActualName = "CombinedIntegerVector";
+      Parameters.Add(new OptionalConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions.", new ItemSet<IManipulator>() { new UniformSomePositionManipulator() }, 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));
@@ -113,14 +117,7 @@
       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 actionSetMergingReducer = new MergingReducer();
@@ -134,5 +131,7 @@
       UniformSubScopesProcessor updateParametersSubScopesProcessor = new UniformSubScopesProcessor();
       ConditionalBranch actionSetSubsumptionBranch = new ConditionalBranch();
-      subsumptionSelector = new ConditionalSelector();
+      UniformSubScopesProcessor setSubsumedToFalseSubScopeProcessor = new UniformSubScopesProcessor();
+      Assigner setSubsumedToFalseAssigner = new Assigner();
+      ConditionalSelector subsumptionSelector = new ConditionalSelector();
       LeftReducer leftReducer = new LeftReducer();
       XCSCheckIfGAShouldBeApplied checkIfGAShouldRun = new XCSCheckIfGAShouldBeApplied();
@@ -143,4 +142,8 @@
       IntCounter currentPopulationSizeCounter = new IntCounter();
       CalculateNumberOfDeletionsOperator calculateNumberOfDeletions = new CalculateNumberOfDeletionsOperator();
+      UniformSubScopesProcessor setDeletionFalseSubScopeProcessor1 = new UniformSubScopesProcessor();
+      UniformSubScopesProcessor setDeletionFalseSubScopeProcessor2 = new UniformSubScopesProcessor();
+      Assigner setDeletionFalseAssigner = new Assigner();
+      InsertInPopulationOperator insertInPopulation = new InsertInPopulationOperator();
       XCSDeletionOperator deletionOperatorAfterGA = new XCSDeletionOperator();
       ConditionalSelector deletionSelectorAfterGA = new ConditionalSelector();
@@ -169,22 +172,20 @@
 
       conditionMatchSelector.CopySelected = new BoolValue(false);
-      conditionMatchSelector.ConditionParameter.ActualName = "MatchCondition";
-
-      conditionMatchSelectorAfterDeletion.CopySelected = new BoolValue(false);
-      conditionMatchSelectorAfterDeletion.ConditionParameter.ActualName = "MatchCondition";
+      conditionMatchSelector.ConditionParameter.ActualName = matchConditionOperator.MatchConditionParameter.ActualName;
 
       countNumberOfUniqueActions.ClassifiersParameter.ActualName = "CombinedIntegerVector";
 
-      countNumberOfUniqueActionsAfterDeletion.ClassifiersParameter.ActualName = "CombinedIntegerVector";
-
-      subscopeVariableCopier.SubScopeIndexParameter.Value = new IntValue(1);
-
+      doDeletionBeforeCovering.ClassifiersParameter.ActualName = "CombinedIntegerVector";
+      doDeletionBeforeCovering.MatchConditionParameter.ActualName = matchConditionOperator.MatchConditionParameter.ActualName;
       doDeletionBeforeCovering.CurrentPopulationSizeParameter.ActualName = "CurrentPopulationSize";
-      doDeletionBeforeCovering.NumberOfUniqueActionsParameter.ActualName = countNumberOfUniqueActions.NumberOfUniqueActionsParameter.ActualName;
       doDeletionBeforeCovering.PopulationSizeParameter.ActualName = "N";
 
       doDeletionBeforeCoveringConditionalBranch.ConditionParameter.ActualName = doDeletionBeforeCovering.DoDeletionParameter.ActualName;
 
+      setDeletionFalseAssigner.LeftSideParameter.ActualName = HASTOBEDELETED;
+      setDeletionFalseAssigner.RightSideParameter.Value = new BoolValue(false);
+
       deletionOperator.NumberToDeleteParameter.ActualName = doDeletionBeforeCovering.NumberToDeleteParameter.ActualName;
+      deletionOperator.HasToBeDeletedParameter.ActualName = HASTOBEDELETED;
       deletionOperator.AverageActionSetSizesParameter.ActualName = "AverageActionSetSize";
       deletionOperator.FitnessesParameter.ActualName = "Fitness";
@@ -195,5 +196,5 @@
       deletionOperator.RandomParameter.ActualName = "Random";
 
-      deletionSelector.ConditionParameter.ActualName = deletionOperator.HasToBeDeletedVariableName;
+      deletionSelector.ConditionParameter.ActualName = HASTOBEDELETED;
       deletionSelector.CopySelected = new BoolValue(false);
 
@@ -219,4 +220,8 @@
       actionSetSubsumptionBranch.ConditionParameter.ActualName = "DoActionSetSubsumption";
 
+      setSubsumedToFalseAssigner.LeftSideParameter.ActualName = HASBEENSUBSUMED;
+      setSubsumedToFalseAssigner.RightSideParameter.Value = new BoolValue(false);
+
+      subsumptionSelector.ConditionParameter.ActualName = HASBEENSUBSUMED;
       subsumptionSelector.CopySelected = new BoolValue(false);
 
@@ -274,5 +279,5 @@
       adaptedGeneticAlgorithmMainLoop.MaximumGenerationsParameter.ActualName = "ZeroIntValue";
       adaptedGeneticAlgorithmMainLoop.QualityParameter.ActualName = "Fitness";
-      adaptedGeneticAlgorithmMainLoop.MutationProbabilityParameter.Value = new PercentValue(10);
+      adaptedGeneticAlgorithmMainLoop.MutationProbabilityParameter.ActualName = "MutationProbability";
       adaptedGeneticAlgorithmMainLoop.MaximizationParameter.Value = new BoolValue(true);
       adaptedGeneticAlgorithmMainLoop.AfterCrossoverParameter.ActualName = AfterCrossoverParameter.Name;
@@ -281,8 +286,14 @@
       currentPopulationSizeCounter.Increment = new IntValue(2);
 
+      insertInPopulation.ClassifiersParameter.ActualName = "CombinedIntegerVector";
+      insertInPopulation.NumerositiesParameter.ActualName = "Numerosity";
+      insertInPopulation.HasToBeDeletedParameter.ActualName = HASTOBEDELETED;
+      insertInPopulation.InsertInPopulationParameter.ActualName = "InsertInPopulation";
+
       calculateNumberOfDeletions.CurrentPopulationSizeParameter.ActualName = "CurrentPopulationSize";
       calculateNumberOfDeletions.PopulationSizeParameter.ActualName = "N";
 
       deletionOperatorAfterGA.NumberToDeleteParameter.ActualName = calculateNumberOfDeletions.NumberOfDeletionsParameter.ActualName;
+      deletionOperatorAfterGA.HasToBeDeletedParameter.ActualName = HASTOBEDELETED;
       deletionOperatorAfterGA.AverageActionSetSizesParameter.ActualName = "AverageActionSetSize";
       deletionOperatorAfterGA.FitnessesParameter.ActualName = "Fitness";
@@ -293,5 +304,5 @@
       deletionOperatorAfterGA.RandomParameter.ActualName = "Random";
 
-      deletionSelectorAfterGA.ConditionParameter.ActualName = deletionOperatorAfterGA.HasToBeDeletedVariableName;
+      deletionSelectorAfterGA.ConditionParameter.ActualName = HASTOBEDELETED;
       deletionSelectorAfterGA.CopySelected = new BoolValue(false);
       #endregion
@@ -307,28 +318,19 @@
       classifierFetcher.Successor = matchCondtionSubScopesProcessor;
       matchCondtionSubScopesProcessor.Operator = matchConditionOperator;
-      matchCondtionSubScopesProcessor.Successor = conditionMatchSelector;
+      matchCondtionSubScopesProcessor.Successor = doDeletionBeforeCovering;
+      doDeletionBeforeCovering.Successor = doDeletionBeforeCoveringConditionalBranch;
+      doDeletionBeforeCoveringConditionalBranch.TrueBranch = setDeletionFalseSubScopeProcessor1;
+      doDeletionBeforeCoveringConditionalBranch.FalseBranch = conditionMatchSelector;
+      setDeletionFalseSubScopeProcessor1.Operator = setDeletionFalseAssigner;
+      setDeletionFalseSubScopeProcessor1.Successor = deletionOperator;
+      deletionOperator.Successor = deletionSelector;
+      deletionSelector.Successor = leftReducerAfterDeletionSelection;
+      //if a classifier with a unique action for the match set has been deleted, then there are still to many classifiers in the population
+      leftReducerAfterDeletionSelection.Successor = doDeletionBeforeCovering;
       conditionMatchSelector.Successor = matchSetSubScopesProcessor;
       matchSetSubScopesProcessor.Operators.Add(new EmptyOperator());
       matchSetSubScopesProcessor.Operators.Add(countNumberOfUniqueActions);
-      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;
-
+      countNumberOfUniqueActions.Successor = covering;
+      matchSetSubScopesProcessor.Successor = matchSetMergingReducer;
       covering.Successor = predictionArrayCalculator;
       predictionArrayCalculator.Successor = actionSelector;
@@ -345,5 +347,7 @@
       updateParametersSubScopesProcessor.Operator = evaluator;
       updateParametersSubScopesProcessor.Successor = actionSetSubsumptionBranch;
-      actionSetSubsumptionBranch.TrueBranch = actionSetSubsumption;
+      actionSetSubsumptionBranch.TrueBranch = setSubsumedToFalseSubScopeProcessor;
+      setSubsumedToFalseSubScopeProcessor.Operator = setSubsumedToFalseAssigner;
+      setSubsumedToFalseSubScopeProcessor.Successor = actionSetSubsumption;
       actionSetSubsumption.Successor = subsumptionSelector;
       subsumptionSelector.Successor = leftReducer;
@@ -359,5 +363,8 @@
       actionSetSubScopesProcessor.Successor = actionSetMergingReducer;
 
-      matchSetMergingReducer.Successor = calculateNumberOfDeletions;
+      matchSetMergingReducer.Successor = setDeletionFalseSubScopeProcessor2;
+      setDeletionFalseSubScopeProcessor2.Operator = setDeletionFalseAssigner;
+      setDeletionFalseSubScopeProcessor2.Successor = insertInPopulation;
+      insertInPopulation.Successor = calculateNumberOfDeletions;
       calculateNumberOfDeletions.Successor = deletionOperatorAfterGA;
       deletionOperatorAfterGA.Successor = deletionSelectorAfterGA;
@@ -388,4 +395,7 @@
       classifierFetcher.OperatorParameter.ActualName = problem.ClassifierFetcherParameter.Name;
 
+      test.FetchedClassifierParameter.ActualName = problem.ClassifierFetcher.CurrentClassifierToMatchParameter.ActualName;
+      test.PossibleActionsParameter.ActualName = problem.PossibleActionsConcreteClassParameter.Name;
+
       actionExecuter.OperatorParameter.ActualName = problem.ActionExecuterParameter.Name;
 
@@ -396,5 +406,5 @@
       problem.ActionSetSubsumptionOperator.NumerositiesParameter.ActualName = "Numerosity";
 
-      subsumptionSelector.ConditionParameter.ActualName = problem.ActionSetSubsumptionOperator.HasBeenSubsumedParameterName;
+      problem.ActionSetSubsumptionOperator.HasBeenSubsumedParameter.ActualName = HASBEENSUBSUMED;
 
       actionSetSubsumption.OperatorParameter.ActualName = problem.ActionSetSubsumptionOperatorParameter.Name;
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/CombinedIntegerVectorManipulator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/CombinedIntegerVectorManipulator.cs	(revision 9109)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/CombinedIntegerVectorManipulator.cs	(revision 9110)
@@ -39,5 +39,5 @@
       get { return (ILookupParameter<CombinedIntegerVector>)Parameters["Child"]; }
     }
-    public ILookupParameter<CombinedIntegerVector> ParentParameter {
+    public ILookupParameter<CombinedIntegerVector> FetchedClassifierParameter {
       get { return (ILookupParameter<CombinedIntegerVector>)Parameters["Parent"]; }
     }
@@ -57,5 +57,5 @@
 
     public sealed override IOperation Apply() {
-      ChildParameter.ActualValue = Manipulate(RandomParameter.ActualValue, ChildParameter.ActualValue, ParentParameter.ActualValue);
+      ChildParameter.ActualValue = Manipulate(RandomParameter.ActualValue, FetchedClassifierParameter.ActualValue, ChildParameter.ActualValue);
       return base.Apply();
     }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Covering/CombinedIntegerVectorCoveringCreator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Covering/CombinedIntegerVectorCoveringCreator.cs	(revision 9109)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Covering/CombinedIntegerVectorCoveringCreator.cs	(revision 9110)
@@ -75,5 +75,5 @@
       CombinedIntegerVector action = (CombinedIntegerVector)ActionParameter.ActualValue.Action;
 
-      newCondition = UniformSomePositionInConditionManipulator.ManipulateCondition(RandomParameter.ActualValue, condition, newCondition, ChangeSymbolProbabilityParameter.ActualValue.Value);
+      newCondition = UniformSomePositionManipulator.ManipulateCondition(RandomParameter.ActualValue, condition, newCondition, ChangeSymbolProbabilityParameter.ActualValue.Value);
 
       CreatedClassifierParameter.ActualValue = new CombinedIntegerVector(newCondition, newCondition.Bounds, action, action.Bounds);
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 9109)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/HeuristicLab.Encodings.CombinedIntegerVectorEncoding-3.3.csproj	(revision 9110)
@@ -119,5 +119,5 @@
     </Compile>
     <Compile Include="Manipulator\UniformOnePositionInConditionManipulator.cs" />
-    <Compile Include="Manipulator\UniformSomePositionInConditionManipulator.cs" />
+    <Compile Include="Manipulator\UniformSomePositionManipulator.cs" />
     <Compile Include="Plugin.cs" />
     <None Include="Properties\AssemblyInfo.cs.frame" />
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Interfaces/ICombinedIntegerVectorManipulator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Interfaces/ICombinedIntegerVectorManipulator.cs	(revision 9109)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Interfaces/ICombinedIntegerVectorManipulator.cs	(revision 9110)
@@ -29,5 +29,5 @@
   public interface ICombinedIntegerVectorManipulator : IManipulator, ICombinedIntegerVectorOperator {
     ILookupParameter<CombinedIntegerVector> ChildParameter { get; }
-    ILookupParameter<CombinedIntegerVector> ParentParameter { get; }
+    ILookupParameter<CombinedIntegerVector> FetchedClassifierParameter { get; }
   }
 }
Index: anches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformSomePositionInConditionManipulator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformSomePositionInConditionManipulator.cs	(revision 9109)
+++ 	(revision )
@@ -1,78 +1,0 @@
-﻿#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.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Encodings.CombinedIntegerVectorEncoding {
-  public class UniformSomePositionInConditionManipulator : CombinedIntegerVectorManipulator {
-
-    public IValueLookupParameter<PercentValue> ProbabilityParameter {
-      get { return (IValueLookupParameter<PercentValue>)Parameters["Probability"]; }
-    }
-    public ILookupParameter<IItemSet<CombinedIntegerVector>> PossibleActionsParameter {
-      get { return (ILookupParameter<IItemSet<CombinedIntegerVector>>)Parameters["PossibleActions"]; }
-    }
-
-    [StorableConstructor]
-    protected UniformSomePositionInConditionManipulator(bool deserializing) : base(deserializing) { }
-    protected UniformSomePositionInConditionManipulator(UniformSomePositionInConditionManipulator original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new UniformSomePositionInConditionManipulator(this, cloner);
-    }
-    public UniformSomePositionInConditionManipulator()
-      : base() {
-      Parameters.Add(new ValueLookupParameter<PercentValue>("Probability", "The probability for each dimension to be manipulated.", new PercentValue(0.5)));
-      Parameters.Add(new LookupParameter<IItemSet<CombinedIntegerVector>>("PossibleActions"));
-    }
-
-    protected override CombinedIntegerVector Manipulate(IRandom random, CombinedIntegerVector parent, CombinedIntegerVector child) {
-      return Manipulate(random, parent, child, ProbabilityParameter.ActualValue.Value, PossibleActionsParameter.ActualValue);
-    }
-
-    public static CombinedIntegerVector Manipulate(IRandom random, CombinedIntegerVector parent, CombinedIntegerVector child, double probability, IItemSet<CombinedIntegerVector> possibleActions) {
-      child = ManipulateCondition(random, parent, child, probability);
-      return ManipulateAction(random, parent, child, probability, possibleActions);
-    }
-
-    public static CombinedIntegerVector ManipulateCondition(IRandom random, CombinedIntegerVector parent, CombinedIntegerVector child, double probability) {
-      int conditionLength = child.Length - child.ActionLength;
-      for (int index = 0; index < child.Length - child.ActionLength; index++) {
-        if (random.NextDouble() < probability) {
-          child = UniformOnePositionInConditionManipulator.Manipulate(parent, child, index);
-        }
-      }
-      return child;
-    }
-
-    public static CombinedIntegerVector ManipulateAction(IRandom random, CombinedIntegerVector parent, CombinedIntegerVector child, double probability, IItemSet<CombinedIntegerVector> possibleActions) {
-      if (child.ActionLength > 0 && random.NextDouble() < probability) {
-        UniformActionManipulator.Manipulate(random, parent, child, possibleActions);
-      }
-      return child;
-    }
-  }
-}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformSomePositionManipulator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformSomePositionManipulator.cs	(revision 9110)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformSomePositionManipulator.cs	(revision 9110)
@@ -0,0 +1,78 @@
+﻿#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.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.CombinedIntegerVectorEncoding {
+  public class UniformSomePositionManipulator : CombinedIntegerVectorManipulator {
+
+    public IValueLookupParameter<PercentValue> ProbabilityParameter {
+      get { return (IValueLookupParameter<PercentValue>)Parameters["Probability"]; }
+    }
+    public ILookupParameter<IItemSet<CombinedIntegerVector>> PossibleActionsParameter {
+      get { return (ILookupParameter<IItemSet<CombinedIntegerVector>>)Parameters["PossibleActions"]; }
+    }
+
+    [StorableConstructor]
+    protected UniformSomePositionManipulator(bool deserializing) : base(deserializing) { }
+    protected UniformSomePositionManipulator(UniformSomePositionManipulator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new UniformSomePositionManipulator(this, cloner);
+    }
+    public UniformSomePositionManipulator()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<PercentValue>("Probability", "The probability for each dimension to be manipulated.", new PercentValue(0.5)));
+      Parameters.Add(new LookupParameter<IItemSet<CombinedIntegerVector>>("PossibleActions"));
+    }
+
+    protected override CombinedIntegerVector Manipulate(IRandom random, CombinedIntegerVector parent, CombinedIntegerVector child) {
+      return Manipulate(random, parent, child, ProbabilityParameter.ActualValue.Value, PossibleActionsParameter.ActualValue);
+    }
+
+    public static CombinedIntegerVector Manipulate(IRandom random, CombinedIntegerVector parent, CombinedIntegerVector child, double probability, IItemSet<CombinedIntegerVector> possibleActions) {
+      child = ManipulateCondition(random, parent, child, probability);
+      return ManipulateAction(random, parent, child, probability, possibleActions);
+    }
+
+    public static CombinedIntegerVector ManipulateCondition(IRandom random, CombinedIntegerVector parent, CombinedIntegerVector child, double probability) {
+      int conditionLength = child.Length - child.ActionLength;
+      for (int index = 0; index < child.Length - child.ActionLength; index++) {
+        if (random.NextDouble() < probability) {
+          child = UniformOnePositionInConditionManipulator.Manipulate(parent, child, index);
+        }
+      }
+      return child;
+    }
+
+    public static CombinedIntegerVector ManipulateAction(IRandom random, CombinedIntegerVector parent, CombinedIntegerVector child, double probability, IItemSet<CombinedIntegerVector> possibleActions) {
+      if (child.ActionLength > 0 && random.NextDouble() < probability) {
+        UniformActionManipulator.Manipulate(random, parent, child, possibleActions);
+      }
+      return child;
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/CoveringOperator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/CoveringOperator.cs	(revision 9109)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/CoveringOperator.cs	(revision 9110)
@@ -101,32 +101,35 @@
         throw new ArgumentException("More classifiers with unique actions shall be created than unique actions are available.");
       }
+      if (count > 0) {
+        CurrentPopulationSizeParameter.ActualValue.Value += count;
 
-      CurrentPopulationSizeParameter.ActualValue.Value += count;
+        int current = CurrentScope.SubScopes.Count;
+        for (int i = 0; i < count; i++) {
+          CurrentScope.SubScopes.Add(new Scope((current + i).ToString()));
+        }
 
-      int current = CurrentScope.SubScopes.Count;
-      for (int i = 0; i < count; i++) {
-        CurrentScope.SubScopes.Add(new Scope((current + i).ToString()));
+        creator.ActionParameter.ActualName = "Action";
+        OperationCollection variableCreation = new OperationCollection() { Parallel = parallel };
+        OperationCollection creation = new OperationCollection();
+        OperationCollection evaluation = new OperationCollection() { Parallel = parallel };
+        for (int i = 0; i < count; i++) {
+          VariableCreator variableCreator = new VariableCreator();
+          int pos = RandomParameter.ActualValue.Next(clone.Count);
+          IClassifier action = clone.ElementAt(pos);
+          clone.Remove(action);
+          variableCreator.CollectedValues.Add(new ValueParameter<IClassifier>("Action", action));
+          variableCreation.Add(ExecutionContext.CreateOperation(variableCreator, CurrentScope.SubScopes[current + i]));
+          creation.Add(ExecutionContext.CreateOperation(creator, CurrentScope.SubScopes[current + i]));
+          evaluation.Add(ExecutionContext.CreateOperation(evaluator, CurrentScope.SubScopes[current + i]));
+        }
+        OperationCollection next = new OperationCollection();
+        next.Add(variableCreation);
+        next.Add(creation);
+        next.Add(evaluation);
+        next.Add(base.Apply());
+        return next;
+      } else {
+        return base.Apply();
       }
-
-      creator.ActionParameter.ActualName = "Action";
-      OperationCollection variableCreation = new OperationCollection() { Parallel = parallel };
-      OperationCollection creation = new OperationCollection();
-      OperationCollection evaluation = new OperationCollection() { Parallel = parallel };
-      for (int i = 0; i < count; i++) {
-        VariableCreator variableCreator = new VariableCreator();
-        int pos = RandomParameter.ActualValue.Next(clone.Count);
-        IClassifier action = clone.ElementAt(pos);
-        clone.Remove(action);
-        variableCreator.CollectedValues.Add(new ValueParameter<IClassifier>("Action", action));
-        variableCreation.Add(ExecutionContext.CreateOperation(variableCreator, CurrentScope.SubScopes[current + i]));
-        creation.Add(ExecutionContext.CreateOperation(creator, CurrentScope.SubScopes[current + i]));
-        evaluation.Add(ExecutionContext.CreateOperation(evaluator, CurrentScope.SubScopes[current + i]));
-      }
-      OperationCollection next = new OperationCollection();
-      next.Add(variableCreation);
-      next.Add(creation);
-      next.Add(evaluation);
-      next.Add(base.Apply());
-      return next;
     }
   }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/DoDeletionBeforeCovering.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/DoDeletionBeforeCovering.cs	(revision 9109)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/DoDeletionBeforeCovering.cs	(revision 9110)
@@ -20,4 +20,5 @@
 #endregion
 
+using System;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -33,9 +34,12 @@
 
     #region Parameter Properties
+    public ILookupParameter<ItemArray<IClassifier>> ClassifiersParameter {
+      get { return (ILookupParameter<ItemArray<IClassifier>>)Parameters["Classifiers"]; }
+    }
+    public ILookupParameter<ItemArray<BoolValue>> MatchConditionParameter {
+      get { return (ILookupParameter<ItemArray<BoolValue>>)Parameters["MatchCondition"]; }
+    }
     public ILookupParameter<IntValue> MinimalNumberOfUniqueActionsParameter {
       get { return (ILookupParameter<IntValue>)Parameters["MinimalNumberOfUniqueActions"]; }
-    }
-    public ILookupParameter<IntValue> NumberOfUniqueActionsParameter {
-      get { return (ILookupParameter<IntValue>)Parameters["NumberOfUniqueActions"]; }
     }
     public ILookupParameter<IntValue> CurrentPopulationSizeParameter {
@@ -60,6 +64,7 @@
     public DoDeletionBeforeCoveringOperator()
       : base() {
+      Parameters.Add(new ScopeTreeLookupParameter<IClassifier>("Classifiers"));
+      Parameters.Add(new ScopeTreeLookupParameter<BoolValue>("MatchCondition"));
       Parameters.Add(new LookupParameter<IntValue>("MinimalNumberOfUniqueActions"));
-      Parameters.Add(new LookupParameter<IntValue>("NumberOfUniqueActions"));
       Parameters.Add(new LookupParameter<IntValue>("CurrentPopulationSize"));
       Parameters.Add(new LookupParameter<IntValue>("PopulationSize"));
@@ -72,6 +77,20 @@
 
     public override IOperation Apply() {
+      IItemSet<IClassifier> uniqueActions = new ItemSet<IClassifier>();
+      var classifiers = ClassifiersParameter.ActualValue;
+      var matchcondition = MatchConditionParameter.ActualValue;
+
+      if (classifiers.Length != matchcondition.Length) {
+        throw new ArgumentException("Number of classifiers is not equal to the number of 'MatchCondition' variables.");
+      }
+
+      for (int i = 0; i < classifiers.Length; i++) {
+        if (matchcondition[i].Value) {
+          uniqueActions.Add(classifiers[i].Action);
+        }
+      }
+
       int populationAfterCovering = MinimalNumberOfUniqueActionsParameter.ActualValue.Value
-                                    - NumberOfUniqueActionsParameter.ActualValue.Value
+                                    - uniqueActions.Count
                                     + CurrentPopulationSizeParameter.ActualValue.Value;
       BoolValue doDeletion = new BoolValue(populationAfterCovering > PopulationSizeParameter.ActualValue.Value);
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Deletion/XCSDeletionOperator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Deletion/XCSDeletionOperator.cs	(revision 9109)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Deletion/XCSDeletionOperator.cs	(revision 9110)
@@ -51,4 +51,7 @@
       get { return (ILookupParameter<ItemArray<IntValue>>)Parameters["Experiences"]; }
     }
+    public ILookupParameter<ItemArray<BoolValue>> HasToBeDeletedParameter {
+      get { return (ILookupParameter<ItemArray<BoolValue>>)Parameters["HasToBeDeleted"]; }
+    }
     public ILookupParameter<IntValue> ThetaDeletionParameter {
       get { return (ILookupParameter<IntValue>)Parameters["ThetaDeletion"]; }
@@ -63,11 +66,4 @@
       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
 
@@ -89,8 +85,8 @@
       Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Fitnesses"));
       Parameters.Add(new ScopeTreeLookupParameter<IntValue>("Experiences"));
+      Parameters.Add(new ScopeTreeLookupParameter<BoolValue>("HasToBeDeleted"));
       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"));
     }
@@ -104,18 +100,10 @@
       var experiences = ExperiencesParameter.ActualValue;
       var averageActionSetSizes = AverageActionSetSizesParameter.ActualValue;
-      var subscopes = CurrentScope.SubScopes;
+      var hasToBeDeleted = HasToBeDeletedParameter.ActualValue;
       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) {
+      if (fitnesses.Length != numerosities.Length && fitnesses.Length != experiences.Length) {
         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)));
-        }
       }
 
@@ -131,9 +119,9 @@
         voteSum = 0;
         for (int cl = 0; cl < fitnesses.Length; cl++) {
-          if (numerosities[cl].Value > 0) {
+          if (numerosities[cl].Value > 0 && !hasToBeDeleted[cl].Value) {
             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;
+                hasToBeDeleted[cl].Value = true;
                 fitnessSum -= fitnesses[cl].Value;
               }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Evaluators/XCSEvaluator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Evaluators/XCSEvaluator.cs	(revision 9109)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Evaluators/XCSEvaluator.cs	(revision 9110)
@@ -56,4 +56,7 @@
     public IValueLookupParameter<IntValue> NumerosityParameter {
       get { return (IValueLookupParameter<IntValue>)Parameters["Numerosity"]; }
+    }
+    public IValueLookupParameter<BoolValue> InsertInPopulationParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["InsertInPopulation"]; }
     }
     public ILookupParameter<DoubleValue> InitialPredictionParameter {
@@ -156,4 +159,5 @@
       Parameters.Add(new LookupParameter<DoubleValue>("AccuracySum", ""));
       Parameters.Add(new ValueLookupParameter<IntValue>("Numerosity", ""));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("InsertInPopulation", ""));
 
       Parameters.Add(new LookupParameter<DoubleValue>("InitialPrediction"));
@@ -178,4 +182,5 @@
         AverageActionSetSizeParameter.ActualValue = new DoubleValue(1);
         NumerosityParameter.ActualValue = new IntValue(1);
+        InsertInPopulationParameter.ActualValue = new BoolValue(false);
       } else {
         Experience += 1;
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/GA/InsertInPopulationOperator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/GA/InsertInPopulationOperator.cs	(revision 9110)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/GA/InsertInPopulationOperator.cs	(revision 9110)
@@ -0,0 +1,100 @@
+﻿#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.Collections.Generic;
+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("InsertInPopulationOperator", "Description missing")]
+  [StorableClass]
+  public class InsertInPopulationOperator : SingleSuccessorOperator {
+
+    #region Parameter Properties
+    public ILookupParameter<ItemArray<BoolValue>> InsertInPopulationParameter {
+      get { return (ILookupParameter<ItemArray<BoolValue>>)Parameters["InsertInPopulation"]; }
+    }
+    public ILookupParameter<ItemArray<IClassifier>> ClassifiersParameter {
+      get { return (ILookupParameter<ItemArray<IClassifier>>)Parameters["Classifiers"]; }
+    }
+    public ILookupParameter<ItemArray<IntValue>> NumerositiesParameter {
+      get { return (ILookupParameter<ItemArray<IntValue>>)Parameters["Numerosity"]; }
+    }
+    public ILookupParameter<ItemArray<BoolValue>> HasToBeDeletedParameter {
+      get { return (ILookupParameter<ItemArray<BoolValue>>)Parameters["HasToBeDeleted"]; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected InsertInPopulationOperator(bool deserializing) : base(deserializing) { }
+    protected InsertInPopulationOperator(InsertInPopulationOperator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public InsertInPopulationOperator()
+      : base() {
+      Parameters.Add(new ScopeTreeLookupParameter<BoolValue>("InsertInPopulation"));
+      Parameters.Add(new ScopeTreeLookupParameter<IClassifier>("Classifiers"));
+      Parameters.Add(new ScopeTreeLookupParameter<IntValue>("Numerosity"));
+      Parameters.Add(new ScopeTreeLookupParameter<BoolValue>("HasToBeDeleted"));
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new InsertInPopulationOperator(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      var numerosities = NumerositiesParameter.ActualValue;
+      var classifiers = ClassifiersParameter.ActualValue;
+      var hasToBeDeleted = HasToBeDeletedParameter.ActualValue;
+      var insertInPopulation = InsertInPopulationParameter.ActualValue;
+
+      if (insertInPopulation.Length != numerosities.Length || insertInPopulation.Length != classifiers.Length
+        || insertInPopulation.Length != hasToBeDeleted.Length) {
+        throw new ArgumentException("Different number of classifiers, numerosity, hasToBeDeleted and insertInPopulation values.");
+      }
+
+      IList<int> insertIndices = new List<int>();
+      for (int i = 0; i < insertInPopulation.Length; i++) {
+        if (insertInPopulation[i].Value) {
+          insertIndices.Add(i);
+        }
+      }
+
+      foreach (var indices in insertIndices) {
+        IClassifier cl = classifiers[indices];
+        for (int i = 0; i < classifiers.Length; i++) {
+          if (!hasToBeDeleted[i].Value && !insertInPopulation[i].Value && cl.Equals(classifiers[i])) {
+            numerosities[i].Value += numerosities[indices].Value;
+            hasToBeDeleted[indices].Value = true;
+            break;
+          }
+        }
+        insertInPopulation[indices].Value = false;
+      }
+
+      return base.Apply();
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/GA/TempSubScopeIDAssigner.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/GA/TempSubScopeIDAssigner.cs	(revision 9110)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/GA/TempSubScopeIDAssigner.cs	(revision 9110)
@@ -0,0 +1,75 @@
+﻿#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("TempSubScopeIDAssigner", "Description missing")]
+  [StorableClass]
+  public class TempSubScopeIDAssigner : SingleSuccessorOperator {
+
+    #region Parameter Properties
+    public IValueLookupParameter<IntValue> LeftSideParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["LeftSide"]; }
+    }
+    private ScopeParameter CurrentScopeParameter {
+      get { return (ScopeParameter)Parameters["CurrentScope"]; }
+    }
+    public IScope CurrentScope {
+      get { return CurrentScopeParameter.ActualValue; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected TempSubScopeIDAssigner(bool deserializing) : base(deserializing) { }
+    protected TempSubScopeIDAssigner(TempSubScopeIDAssigner original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public TempSubScopeIDAssigner()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<IntValue>("LeftSide"));
+      Parameters.Add(new ScopeParameter("CurrentScope"));
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new TempSubScopeIDAssigner(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      var subscopes = CurrentScope.SubScopes;
+      string name = LeftSideParameter.ActualName;
+
+      for (int i = 0; i < subscopes.Count; i++) {
+        if (subscopes[i].Variables.ContainsKey(name)) {
+          ((IntValue)subscopes[i].Variables[name].Value).Value = i;
+        } else {
+          subscopes[i].Variables.Add(new Variable(name, new IntValue(i)));
+        }
+      }
+
+      return base.Apply();
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/GA/XCSAfterCrossoverOperator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/GA/XCSAfterCrossoverOperator.cs	(revision 9109)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/GA/XCSAfterCrossoverOperator.cs	(revision 9110)
@@ -55,4 +55,10 @@
       get { return (IValueLookupParameter<DoubleValue>)Parameters["Fitness"]; }
     }
+    public IValueLookupParameter<BoolValue> InsertInPopulationParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["InsertInPopulation"]; }
+    }
+    public IValueLookupParameter<IntValue> TempIDParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["TempID"]; }
+    }
     public ILookupParameter<IntValue> CurrentIterationParameter {
       get { return (ILookupParameter<IntValue>)Parameters["CurrentIteration"]; }
@@ -86,4 +92,6 @@
       Parameters.Add(new ValueLookupParameter<DoubleValue>("Error"));
       Parameters.Add(new ValueLookupParameter<DoubleValue>("Fitness"));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("InsertInPopulation"));
+      Parameters.Add(new ValueLookupParameter<IntValue>("TempID"));
       Parameters.Add(new LookupParameter<IntValue>("CurrentIteration"));
       Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("ParentAverageActionSetSize"));
@@ -108,4 +116,6 @@
       ErrorParameter.ActualValue = new DoubleValue(0.25 * parentPrecisionError.Select(x => x.Value).Average());
       FitnessParameter.ActualValue = new DoubleValue(0.1 * parentFitness.Select(x => x.Value).Average());
+      InsertInPopulationParameter.ActualValue = new BoolValue(true);
+      TempIDParameter.ActualValue = new IntValue(-1);
       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 9109)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/HeuristicLab.Encodings.ConditionActionEncoding-3.3.csproj	(revision 9110)
@@ -92,4 +92,5 @@
     <Compile Include="Evaluators\IConditionActionEvaluator.cs" />
     <Compile Include="Evaluators\IXCSEvaluator.cs" />
+    <Compile Include="GA\InsertInPopulationOperator.cs" />
     <Compile Include="GA\XCSAfterCrossoverOperator.cs" />
     <Compile Include="IClassifier.cs" />
@@ -102,6 +103,6 @@
     <Compile Include="Operator\MatchActionOperator.cs" />
     <Compile Include="Operator\MatchConditionOperator.cs" />
-    <Compile Include="Operator\SubScopeVariableCopier.cs" />
     <Compile Include="Operator\SumAccuracy.cs" />
+    <Compile Include="GA\TempSubScopeIDAssigner.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Plugin.cs" />
@@ -111,5 +112,7 @@
     <Compile Include="Selectors\IMatchSelector.cs" />
     <Compile Include="Selectors\MatchSelector.cs" />
-    <Compile Include="Subsumption\ActionSetSubsumptionoperator.cs" />
+    <Compile Include="Subsumption\ActionSetSubsumptionOperator.cs" />
+    <Compile Include="Subsumption\CheckGASubsumptionOperator.cs" />
+    <Compile Include="Subsumption\ExecuteGASubsumptionOperator.cs" />
     <Compile Include="Subsumption\IActionSetSubsumption.cs" />
     <None Include="Properties\AssemblyInfo.cs.frame" />
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionProblem.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionProblem.cs	(revision 9109)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionProblem.cs	(revision 9110)
@@ -33,6 +33,7 @@
     IParameter ThetaMinimalNumberOfActionsParameter { get; }
 
+    IParameter PossibleActionsConcreteClassParameter { get; }
     IParameter PossibleActionsParameter { get; }
-    IItemSet<IClassifier> PossibleActions { get; }
+    //IItemSet<IClassifier> PossibleActions { get; }
 
     ICoveringSolutionCreator CoveringSolutionCreator { get; }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/MatchConditionOperator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/MatchConditionOperator.cs	(revision 9109)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/MatchConditionOperator.cs	(revision 9110)
@@ -31,5 +31,5 @@
   [StorableClass]
   public class MatchConditionOperator : SingleSuccessorOperator {
-    protected ILookupParameter<BoolValue> MatchConditionParameter {
+    public ILookupParameter<BoolValue> MatchConditionParameter {
       get { return (ILookupParameter<BoolValue>)Parameters["MatchCondition"]; }
     }
Index: anches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/SubScopeVariableCopier.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/SubScopeVariableCopier.cs	(revision 9109)
+++ 	(revision )
@@ -1,72 +1,0 @@
-﻿#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 9110)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Subsumption/ActionSetSubsumptionOperator.cs	(revision 9110)
@@ -0,0 +1,115 @@
+﻿#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<ItemArray<BoolValue>> HasBeenSubsumedParameter {
+      get { return (ILookupParameter<ItemArray<BoolValue>>)Parameters["HasBeenSubsumed"]; }
+    }
+    public ILookupParameter<DoubleValue> ErrorZeroParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["ErrorZero"]; }
+    }
+    public ILookupParameter<IntValue> ThetaSubsumptionParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["ThetaSubsumption"]; }
+    }
+    #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 ScopeTreeLookupParameter<BoolValue>("HasBeenSubsumed"));
+      Parameters.Add(new LookupParameter<DoubleValue>("ErrorZero"));
+      Parameters.Add(new LookupParameter<IntValue>("ThetaSubsumption"));
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ActionSetSubsumptionOperator(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      var classifiers = ClassifiersParameter.ActualValue;
+      var numerosities = NumerositiesParameter.ActualValue;
+      var experiences = ExperiencesParameter.ActualValue;
+      var hasBeenSubsumed = HasBeenSubsumedParameter.ActualValue;
+      var errors = ErrorsParameter.ActualValue;
+      if (errors.Length != classifiers.Length || errors.Length != numerosities.Length
+        || errors.Length != experiences.Length || errors.Length != hasBeenSubsumed.Length) {
+        throw new ArgumentException("The number of classifiers, error, numerosity, hasBeenSubsumed and experience values is not equal.");
+      }
+
+      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;
+            hasBeenSubsumed[i].Value = true;
+          }
+        }
+      }
+
+      return base.Apply();
+    }
+
+    private bool CouldSubsume(IntValue exp, DoubleValue error) {
+      return exp.Value > ThetaSubsumptionParameter.ActualValue.Value && error.Value < ErrorZeroParameter.ActualValue.Value;
+    }
+  }
+}
Index: anches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Subsumption/ActionSetSubsumptionoperator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Subsumption/ActionSetSubsumptionoperator.cs	(revision 9109)
+++ 	(revision )
@@ -1,136 +1,0 @@
-﻿#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/CheckGASubsumptionOperator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Subsumption/CheckGASubsumptionOperator.cs	(revision 9110)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Subsumption/CheckGASubsumptionOperator.cs	(revision 9110)
@@ -0,0 +1,125 @@
+﻿#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("CheckGASubsumptionOperator", "Description missing")]
+  [StorableClass]
+  public class CheckGASubsumptionOperator : SingleSuccessorOperator {
+
+    #region Parameter Properties
+    public ILookupParameter<IClassifier> ChildClassifiersParameter {
+      get { return (ILookupParameter<IClassifier>)Parameters["ChildClassifiers"]; }
+    }
+    public ILookupParameter<ItemArray<IClassifier>> ParentsClassifiersParameter {
+      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<ItemArray<IntValue>> TempIDParameter {
+      get { return (ILookupParameter<ItemArray<IntValue>>)Parameters["TempID"]; }
+    }
+    public ILookupParameter<DoubleValue> ErrorZeroParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["ErrorZero"]; }
+    }
+    public ILookupParameter<IntValue> ThetaSubsumptionParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["ThetaSubsumption"]; }
+    }
+    public IValueLookupParameter<IntValue> SubsumedByParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["SubsumedBy"]; }
+    }
+    public IValueLookupParameter<BoolValue> SubsumedParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["Subsumed"]; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected CheckGASubsumptionOperator(bool deserializing) : base(deserializing) { }
+    protected CheckGASubsumptionOperator(CheckGASubsumptionOperator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public CheckGASubsumptionOperator()
+      : base() {
+      Parameters.Add(new LookupParameter<IClassifier>("ChildClassifiers"));
+      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 ScopeTreeLookupParameter<IntValue>("TempID"));
+      Parameters.Add(new LookupParameter<DoubleValue>("ErrorZero"));
+      Parameters.Add(new LookupParameter<IntValue>("ThetaSubsumption"));
+      Parameters.Add(new ValueLookupParameter<IntValue>("SubsumedBy"));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Subsumed"));
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new CheckGASubsumptionOperator(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      var child = ChildClassifiersParameter.ActualValue;
+      var parents = ParentsClassifiersParameter.ActualValue;
+      var numerosities = NumerositiesParameter.ActualValue;
+      var experiences = ExperiencesParameter.ActualValue;
+      var tempIDs = TempIDParameter.ActualValue;
+      var errors = ErrorsParameter.ActualValue;
+      if (errors.Length != parents.Length || errors.Length != numerosities.Length
+        || errors.Length != experiences.Length || errors.Length != tempIDs.Length) {
+        throw new ArgumentException("The number of classifiers, error, numerosity, tempIDs and experience values is not equal.");
+      }
+
+      SubsumedByParameter.ActualValue = new IntValue(-1);
+      SubsumedParameter.ActualValue = new BoolValue(false);
+
+      for (int i = 0; i < parents.Length; i++) {
+        IClassifier curParent = parents[i];
+        if (curParent.MatchAction(child)) {
+          if (CouldSubsume(experiences[i], errors[i])) {
+            if (curParent.IsMoreGeneral(child)) {
+              SubsumedByParameter.ActualValue.Value = i;
+              SubsumedParameter.ActualValue.Value = true;
+              break;
+            }
+          }
+        }
+      }
+
+      return base.Apply();
+    }
+
+    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/ExecuteGASubsumptionOperator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Subsumption/ExecuteGASubsumptionOperator.cs	(revision 9110)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Subsumption/ExecuteGASubsumptionOperator.cs	(revision 9110)
@@ -0,0 +1,88 @@
+﻿#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.Collections.Generic;
+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("ExecuteGASubsumptionOperator", "Description missing")]
+  [StorableClass]
+  public class ExecuteGASubsumptionOperator : SingleSuccessorOperator {
+
+    #region Parameter Properties
+    public ILookupParameter<ItemArray<IntValue>> TempIDParameter {
+      get { return (ILookupParameter<ItemArray<IntValue>>)Parameters["TempID"]; }
+    }
+    public ILookupParameter<ItemArray<IntValue>> NumerositiesParameter {
+      get { return (ILookupParameter<ItemArray<IntValue>>)Parameters["Numerosities"]; }
+    }
+    public ILookupParameter<ItemArray<IntValue>> SubsumedByParameter {
+      get { return (ILookupParameter<ItemArray<IntValue>>)Parameters["SubsumedBy"]; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected ExecuteGASubsumptionOperator(bool deserializing) : base(deserializing) { }
+    protected ExecuteGASubsumptionOperator(ExecuteGASubsumptionOperator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public ExecuteGASubsumptionOperator()
+      : base() {
+      Parameters.Add(new ScopeTreeLookupParameter<IntValue>("TempID"));
+      Parameters.Add(new ScopeTreeLookupParameter<IntValue>("Numerosities"));
+      Parameters.Add(new ScopeTreeLookupParameter<IntValue>("SubsumedBy"));
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ExecuteGASubsumptionOperator(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      var tempId = TempIDParameter.ActualValue;
+      var numerosities = NumerositiesParameter.ActualValue;
+      var subsumedBy = SubsumedByParameter.ActualValue;
+
+      if (tempId.Length != numerosities.Length || tempId.Length != subsumedBy.Length) {
+        throw new ArgumentException("The number of tempId, numerosity and subsumedBy values is not equal.");
+      }
+
+      IList<int> ids = new List<int>();
+      for (int i = 0; i < tempId.Length; i++) {
+        if (subsumedBy[i].Value >= 0) {
+          ids.Add(subsumedBy[i].Value);
+          numerosities[i].Value = 0;
+        }
+      }
+
+      foreach (var id in ids) {
+        var subsumedId = tempId.FindIndex(x => x.Value == id);
+        numerosities[subsumedId].Value++;
+      }
+
+      return base.Apply();
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Subsumption/IActionSetSubsumption.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Subsumption/IActionSetSubsumption.cs	(revision 9109)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Subsumption/IActionSetSubsumption.cs	(revision 9110)
@@ -31,8 +31,7 @@
     ILookupParameter<ItemArray<IntValue>> ExperiencesParameter { get; }
     ILookupParameter<ItemArray<DoubleValue>> ErrorsParameter { get; }
+    ILookupParameter<ItemArray<BoolValue>> HasBeenSubsumedParameter { get; }
     ILookupParameter<DoubleValue> ErrorZeroParameter { get; }
     ILookupParameter<IntValue> ThetaSubsumptionParameter { get; }
-
-    string HasBeenSubsumedParameterName { get; }
   }
 }
Index: /branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/Implementation/ConditionActionClassificationProblem.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/Implementation/ConditionActionClassificationProblem.cs	(revision 9109)
+++ /branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/Implementation/ConditionActionClassificationProblem.cs	(revision 9110)
@@ -70,4 +70,7 @@
       get { return (IFixedValueParameter<ItemSet<IClassifier>>)Parameters["PossibleActions"]; }
     }
+    public IFixedValueParameter<ItemSet<CombinedIntegerVector>> PossibleActionsConcreteClassParameter {
+      get { return (IFixedValueParameter<ItemSet<CombinedIntegerVector>>)Parameters["PossibleActionsConcreteClass"]; }
+    }
     public IFixedValueParameter<IntValue> ThetaMinimalNumberOfActionsParameter {
       get { return (IFixedValueParameter<IntValue>)Parameters["ThetaMinimalNumberOfActions"]; }
@@ -95,10 +98,16 @@
       get { return ProblemDataParameter.Value; }
     }
+    IParameter IConditionActionProblem.PossibleActionsConcreteClassParameter {
+      get { return PossibleActionsConcreteClassParameter; }
+    }
+    public ItemSet<CombinedIntegerVector> PossibleActionsConcreteClass {
+      get { return PossibleActionsConcreteClassParameter.Value; }
+    }
     IParameter IConditionActionProblem.PossibleActionsParameter {
       get { return PossibleActionsParameter; }
     }
-    IItemSet<IClassifier> IConditionActionProblem.PossibleActions {
-      get { return PossibleActions; }
-    }
+    //IItemSet<IClassifier> IConditionActionProblem.PossibleActions {
+    //  get { return PossibleActions; }
+    //}
     public ItemSet<IClassifier> PossibleActions {
       get { return PossibleActionsParameter.Value; }
@@ -121,9 +130,9 @@
 
 
-    public ActionSetSubsumptionoperator ActionSetSubsumptionOperator {
+    public ActionSetSubsumptionOperator ActionSetSubsumptionOperator {
       get { return ActionSetSubsumptionOperatorParameter.Value; }
     }
-    public ValueParameter<ActionSetSubsumptionoperator> ActionSetSubsumptionOperatorParameter {
-      get { return (ValueParameter<ActionSetSubsumptionoperator>)Parameters[ActionSetSubsumptionOperatorParameterName]; }
+    public ValueParameter<ActionSetSubsumptionOperator> ActionSetSubsumptionOperatorParameter {
+      get { return (ValueParameter<ActionSetSubsumptionOperator>)Parameters[ActionSetSubsumptionOperatorParameterName]; }
     }
     IActionSetSubsumption IConditionActionProblem.ActionSetSubsumptionOperator { get { return ActionSetSubsumptionOperator; } }
@@ -175,4 +184,5 @@
       Parameters.Add(new ValueParameter<CombinedIntegerVectorClassifierFetcher>(ClassifierFetcherParameterName, "", new CombinedIntegerVectorClassifierFetcher()));
       Parameters.Add(new FixedValueParameter<ItemSet<IClassifier>>("PossibleActions"));
+      Parameters.Add(new FixedValueParameter<ItemSet<CombinedIntegerVector>>("PossibleActionsConcreteClass"));
       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)));
 
@@ -180,5 +190,5 @@
       Parameters.Add(new FixedValueParameter<PercentValue>("ChangeSymbolProbabilityInCovering", "", new PercentValue(0.5)));
 
-      Parameters.Add(new ValueParameter<ActionSetSubsumptionoperator>(ActionSetSubsumptionOperatorParameterName, "", new ActionSetSubsumptionoperator()));
+      Parameters.Add(new ValueParameter<ActionSetSubsumptionOperator>(ActionSetSubsumptionOperatorParameterName, "", new ActionSetSubsumptionOperator()));
 
       Evaluator.InitialErrorParameter.ActualName = "InitialError";
@@ -237,6 +247,8 @@
       }
       PossibleActions.Clear();
+      PossibleActionsConcreteClass.Clear();
       while (!done) {
         PossibleActions.Add(new CombinedIntegerVector(curPos, actionLength, actionBounds));
+        PossibleActionsConcreteClass.Add(new CombinedIntegerVector(curPos, actionLength, actionBounds));
         curPos = GetNextAction(curPos, actionBounds, out done);
       }
