Index: branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystemMainLoop.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystemMainLoop.cs	(revision 9089)
+++ branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystemMainLoop.cs	(revision 9090)
@@ -54,8 +54,8 @@
     #region private properties
     private SolutionsCreator initialSolutionsCreator;
-    private SolutionsCreator coveringMechanism;
     private MatchConditionOperator matchConditionOperator;
     private PredictionArrayCalculator predictionArrayCalculator;
     private ActionSelector actionSelector;
+    private CoveringOperator covering;
 
     private Placeholder evaluator;
@@ -100,11 +100,9 @@
       ConditionalSelector conditionMatchSelector = new ConditionalSelector();
       ConditionalSelector actionMatchSelector = new ConditionalSelector();
-      SubScopesProcessor coveringSubScopesProcessor = new SubScopesProcessor();
-      SubScopesCounter matchsetCounter = new SubScopesCounter();
-      Comparator comparator = new Comparator();
-      ConditionalBranch coveringConditionalBranch = new ConditionalBranch();
+      SubScopesProcessor matchSetSubScopesProcessor = new SubScopesProcessor();
+      CountNumberOfUniqueActions countNumberOfUniqueActions = new CountNumberOfUniqueActions();
+      covering = new CoveringOperator();
       MergingReducer mergingReducer = new MergingReducer();
       MergingReducer mergingReducerWithSuccessor = new MergingReducer();
-      coveringMechanism = new SolutionsCreator();
       evaluator = new Placeholder();
       SubScopesProcessor actionSetSubScopesProcessor = new SubScopesProcessor();
@@ -137,16 +135,9 @@
       conditionMatchSelector.ConditionParameter.ActualName = "MatchCondition";
 
-      matchsetCounter.Name = "Count number of rules in match set";
-      matchsetCounter.AccumulateParameter.Value = new BoolValue(false);
-      matchsetCounter.ValueParameter.ActualName = "MatchSetCount";
-
-      comparator.Comparison = new Comparison(ComparisonType.LessOrEqual);
-      comparator.LeftSideParameter.ActualName = matchsetCounter.ValueParameter.ActualName;
-      comparator.ResultParameter.ActualName = "Covering";
-      //more than zero solutions have to be selected
-      comparator.RightSideParameter.ActualName = "ZeroIntValue";
-
-      coveringConditionalBranch.Name = "Covering Branch";
-      coveringConditionalBranch.ConditionParameter.ActualName = "Covering";
+      countNumberOfUniqueActions.ClassifiersParameter.ActualName = "CombinedIntegerVector";
+
+      covering.ActionsInMatchSetParameter.ActualName = countNumberOfUniqueActions.UniqueActionsParameter.ActualName;
+      covering.ParallelParameter.Value.Value = true;
+      covering.RandomParameter.ActualName = "Random";
 
       matchActionSubScopesProcessor.Operator = matchActionOperator;
@@ -154,6 +145,4 @@
       matchActionOperator.MatchParameter.ActualName = "CombinedIntegerVector";
       matchActionOperator.TargetMatchParameter.ActualName = actionSelector.SelectedActionParameter.ActualName;
-
-      coveringMechanism.NumberOfSolutionsParameter.ActualName = "OneIntValue";
 
       predictionArrayCalculator.MatchParameter.ActualName = "CombinedIntegerVector";
@@ -211,13 +200,10 @@
       //adaptedGeneticAlgorithmMainLoop.Successor = conditionMatchSelector;
 
-      conditionMatchSelector.Successor = coveringSubScopesProcessor;
-      coveringSubScopesProcessor.Operators.Add(new EmptyOperator());
-      coveringSubScopesProcessor.Operators.Add(matchsetCounter);
-      coveringSubScopesProcessor.Successor = mergingReducerWithSuccessor;
-      matchsetCounter.Successor = comparator;
-      comparator.Successor = coveringConditionalBranch;
-      coveringConditionalBranch.TrueBranch = coveringMechanism;
-      coveringConditionalBranch.FalseBranch = new EmptyOperator();
-      coveringConditionalBranch.Successor = predictionArrayCalculator;
+      conditionMatchSelector.Successor = matchSetSubScopesProcessor;
+      matchSetSubScopesProcessor.Operators.Add(new EmptyOperator());
+      matchSetSubScopesProcessor.Operators.Add(countNumberOfUniqueActions);
+      matchSetSubScopesProcessor.Successor = mergingReducerWithSuccessor;
+      countNumberOfUniqueActions.Successor = covering;
+      covering.Successor = predictionArrayCalculator;
       predictionArrayCalculator.Successor = actionSelector;
       actionSelector.Successor = matchActionSubScopesProcessor;
@@ -253,7 +239,4 @@
       initialSolutionsCreator.EvaluatorParameter.ActualName = problem.EvaluatorParameter.Name;
 
-      coveringMechanism.SolutionCreatorParameter.ActualName = problem.SolutionCreatorParameter.Name;
-      coveringMechanism.EvaluatorParameter.ActualName = problem.EvaluatorParameter.Name;
-
       problem.ActionExecuter.SelectedActionParameter.ActualName = actionSelector.SelectedActionParameter.ActualName;
 
@@ -266,5 +249,10 @@
       actionExecuter.OperatorParameter.ActualName = problem.ActionExecuterParameter.Name;
 
-      matchConditionOperator.TargetMatchParameter.ActualName = problem.ClassifierFetcher.CurrentClassifierToMatchParameter.Name;
+      matchConditionOperator.TargetMatchParameter.ActualName = problem.ClassifierFetcher.CurrentClassifierToMatchParameter.ActualName;
+
+      covering.SolutionCreatorParameter.ActualName = problem.CoveringSolutionCreatorParameter.Name;
+      covering.EvaluatorParameter.ActualName = problem.EvaluatorParameter.Name;
+      covering.MinimalNumberOfUniqueActionsParameter.ActualName = problem.ThetaMinimalNumberOfActionsParameter.Name;
+      covering.PossibleActionsParameter.ActualName = problem.PossibleActionsParameter.Name;
 
       predictionArrayCalculator.PredictionParameter.ActualName = problem.Evaluator.PredictionParameter.ActualName;
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Covering/CombinedIntegerVectorCoveringCreator.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Covering/CombinedIntegerVectorCoveringCreator.cs	(revision 9089)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Covering/CombinedIntegerVectorCoveringCreator.cs	(revision 9090)
@@ -28,5 +28,5 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Encodings.CombinedIntegerVectorEncoding.Covering {
+namespace HeuristicLab.Encodings.CombinedIntegerVectorEncoding {
   [Item("CombinedIntegerVectorCoveringCreator", "Description missing")]
   [StorableClass]
@@ -43,7 +43,11 @@
       get { return (IValueLookupParameter<IClassifier>)Parameters["CreatedClassifier"]; }
     }
-    public IValueLookupParameter<PercentValue> ChangeSymbolProbabilityParameter {
-      get { return (IValueLookupParameter<PercentValue>)Parameters["ChangeSymbolProbability"]; }
+    public ILookupParameter<PercentValue> ChangeSymbolProbabilityParameter {
+      get { return (ILookupParameter<PercentValue>)Parameters["ChangeSymbolProbability"]; }
     }
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
     #endregion
 
@@ -61,14 +65,17 @@
       Parameters.Add(new LookupParameter<IClassifier>("Action"));
       Parameters.Add(new ValueLookupParameter<IClassifier>("CreatedClassifier"));
-      Parameters.Add(new ValueLookupParameter<PercentValue>("ChangeSymbolProbability"));
+      Parameters.Add(new LookupParameter<PercentValue>("ChangeSymbolProbability"));
+      Parameters.Add(new LookupParameter<IRandom>("Random"));
     }
 
     public override IOperation Apply() {
+      CombinedIntegerVector newCondition = (CombinedIntegerVector)CoverClassifierParameter.ActualValue.Condition.Clone();
+
       CombinedIntegerVector condition = (CombinedIntegerVector)CoverClassifierParameter.ActualValue.Condition;
       CombinedIntegerVector action = (CombinedIntegerVector)ActionParameter.ActualValue.Action;
 
-      //TODO: manipulation
+      newCondition = UniformSomePositionInConditionManipulator.ManipulateCondition(RandomParameter.ActualValue, condition, newCondition, ChangeSymbolProbabilityParameter.ActualValue.Value);
 
-      CreatedClassifierParameter.ActualValue = new CombinedIntegerVector(condition, condition.Bounds, action, action.Bounds);
+      CreatedClassifierParameter.ActualValue = new CombinedIntegerVector(newCondition, newCondition.Bounds, action, action.Bounds);
       return base.Apply();
     }
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Crossovers/SinglePointCrossover.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Crossovers/SinglePointCrossover.cs	(revision 9089)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Crossovers/SinglePointCrossover.cs	(revision 9090)
@@ -38,7 +38,32 @@
     }
 
+    public static CombinedIntegerVector Apply(IRandom random, CombinedIntegerVector parent1, CombinedIntegerVector parent2) {
+      if (parent1.Length != parent2.Length && parent1.ActionLength != parent2.ActionLength && parent1.Bounds.Equals(parent2.Bounds))
+        throw new ArgumentException("SinglePointCrossover: The parents are of different length.");
+
+      int length = parent1.Length;
+      int actionLength = parent1.ActionLength;
+      int conditionLength = length - actionLength;
+      int[] result = new int[length];
+      int breakPoint = random.Next(1, conditionLength);
+
+      for (int i = 0; i < breakPoint; i++) {
+        result[i] = parent1[i];
+      }
+      for (int i = breakPoint; i < conditionLength; i++) {
+        result[i] = parent2[i];
+      }
+
+      CombinedIntegerVector actionParent = random.Next(2) == 1 ? parent1 : parent2;
+      for (int i = conditionLength; i < length; i++) {
+        result[i] = actionParent[i];
+      }
+
+      return new CombinedIntegerVector(result, actionLength, parent1.Bounds);
+    }
+
     protected override CombinedIntegerVector Cross(IRandom random, ItemArray<CombinedIntegerVector> parents) {
       if (parents.Length != 2) throw new ArgumentException("ERROR in SinglePointCrossover: The number of parents is not equal to 2");
-      return new CombinedIntegerVector(HeuristicLab.Encodings.IntegerVectorEncoding.SinglePointCrossover.Apply(random, parents[0], parents[1]), parents[0].ActionLength, parents[0].Bounds);
+      return Apply(random, parents[0], parents[1]);
     }
   }
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 9089)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/HeuristicLab.Encodings.CombinedIntegerVectorEncoding-3.3.csproj	(revision 9090)
@@ -118,5 +118,5 @@
     </Compile>
     <Compile Include="Manipulator\UniformOnePositionInConditionManipulator.cs" />
-    <Compile Include="Manipulator\UniformSomePositionsManipulator.cs" />
+    <Compile Include="Manipulator\UniformSomePositionInConditionManipulator.cs" />
     <Compile Include="Plugin.cs" />
     <None Include="Properties\AssemblyInfo.cs.frame" />
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformOnePositionInConditionManipulator.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformOnePositionInConditionManipulator.cs	(revision 9089)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformOnePositionInConditionManipulator.cs	(revision 9090)
@@ -46,5 +46,5 @@
 
     public static CombinedIntegerVector Manipulate(CombinedIntegerVector parent, CombinedIntegerVector child, int index) {
-      int max = child.Bounds[index % child.Bounds.Rows, 1];
+      int max = child.Bounds[index % child.Bounds.Rows, 1] - 1;
       if (child[index].Equals(max)) {
         child[index] = parent[index];
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformSomePositionInConditionManipulator.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformSomePositionInConditionManipulator.cs	(revision 9090)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformSomePositionInConditionManipulator.cs	(revision 9090)
@@ -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 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/UniformSomePositionsManipulator.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformSomePositionsManipulator.cs	(revision 9089)
+++ 	(revision )
@@ -1,69 +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.Manipulator {
-  public class UniformSomePositionsManipulator : 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 UniformSomePositionsManipulator(bool deserializing) : base(deserializing) { }
-    protected UniformSomePositionsManipulator(UniformSomePositionsManipulator original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new UniformSomePositionsManipulator(this, cloner);
-    }
-    public UniformSomePositionsManipulator()
-      : 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) {
-      for (int index = 0; index < child.Length - child.ActionLength; index++) {
-        if (random.NextDouble() < probability) {
-          UniformOnePositionInConditionManipulator.Manipulate(parent, child, index);
-        }
-      }
-
-      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 9089)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/CoveringOperator.cs	(revision 9090)
@@ -35,7 +35,4 @@
 
     #region Parameter Properties
-    public ILookupParameter<IClassifier> CoverClassifierParameter {
-      get { return (ILookupParameter<IClassifier>)Parameters["CoverClassifier"]; }
-    }
     public ILookupParameter<IItemSet<IClassifier>> ActionsInMatchSetParameter {
       get { return (ILookupParameter<IItemSet<IClassifier>>)Parameters["ActionsInMatchSet"]; }
@@ -48,5 +45,5 @@
     }
     public IValueLookupParameter<IOperator> EvaluatorParameter {
-      get { return (IValueLookupParameter<IOperator>)Parameters[" Evaluator"]; }
+      get { return (IValueLookupParameter<IOperator>)Parameters["Evaluator"]; }
     }
     public IValueLookupParameter<ICoveringSolutionCreator> SolutionCreatorParameter {
@@ -78,6 +75,6 @@
       : base() {
       Parameters.Add(new LookupParameter<IClassifier>("CoverClassifier"));
-      Parameters.Add(new ScopeTreeLookupParameter<IClassifier>("ActionsInMatchSet"));
-      Parameters.Add(new ScopeTreeLookupParameter<IClassifier>("PossibleActions"));
+      Parameters.Add(new LookupParameter<IItemSet<IClassifier>>("ActionsInMatchSet"));
+      Parameters.Add(new LookupParameter<IItemSet<IClassifier>>("PossibleActions"));
       Parameters.Add(new LookupParameter<IntValue>("MinimalNumberOfUniqueActions"));
       Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator"));
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/ICovering.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/ICovering.cs	(revision 9089)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/ICovering.cs	(revision 9090)
@@ -26,5 +26,4 @@
 namespace HeuristicLab.Encodings.ConditionActionEncoding {
   public interface ICovering : IStochasticOperator {
-    ILookupParameter<IClassifier> CoverClassifierParameter { get; }
     ILookupParameter<IItemSet<IClassifier>> ActionsInMatchSetParameter { get; }
     ILookupParameter<IItemSet<IClassifier>> PossibleActionsParameter { get; }
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/ICoveringSolutionCreator.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/ICoveringSolutionCreator.cs	(revision 9089)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/ICoveringSolutionCreator.cs	(revision 9090)
@@ -23,11 +23,14 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
 
 namespace HeuristicLab.Encodings.ConditionActionEncoding {
-  public interface ICoveringSolutionCreator : IOperator, IParameterizedNamedItem, INamedItem, IParameterizedItem, IItem, IContent, IDeepCloneable, ICloneable {
+  public interface ICoveringSolutionCreator : IOperator, IParameterizedNamedItem, INamedItem, IParameterizedItem, IItem, IContent, IDeepCloneable, ICloneable, IStochasticOperator {
     ILookupParameter<IClassifier> CoverClassifierParameter { get; }
     ILookupParameter<IClassifier> ActionParameter { get; }
 
     IValueLookupParameter<IClassifier> CreatedClassifierParameter { get; }
+    ILookupParameter<PercentValue> ChangeSymbolProbabilityParameter { get; }
   }
 }
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionProblem.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionProblem.cs	(revision 9089)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionProblem.cs	(revision 9090)
@@ -31,8 +31,12 @@
     IParameter ClassifierFetcherParameter { get; }
     IClassifierFetcher ClassifierFetcher { get; }
+    IParameter ThetaMinimalNumberOfActionsParameter { get; }
 
     IParameter PossibleActionsParameter { get; }
     IItemSet<IClassifier> PossibleActions { get; }
 
+    ICoveringSolutionCreator CoveringSolutionCreator { get; }
+    IParameter CoveringSolutionCreatorParameter { get; }
+
     new IXCSEvaluator Evaluator { get; }
   }
Index: branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/CountNumberOfUniqueActions.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/CountNumberOfUniqueActions.cs	(revision 9089)
+++ branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/CountNumberOfUniqueActions.cs	(revision 9090)
@@ -22,4 +22,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Operators;
 using HeuristicLab.Parameters;
@@ -37,4 +38,7 @@
       get { return (IValueLookupParameter<IItemSet<IClassifier>>)Parameters["UniqueActions"]; }
     }
+    public IValueLookupParameter<IntValue> NumberOfUniqueActionsParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["NumberOfUniqueActions"]; }
+    }
 
     [StorableConstructor]
@@ -50,5 +54,7 @@
       Parameters.Add(new ScopeTreeLookupParameter<IClassifier>("Classifiers"));
       Parameters.Add(new ValueLookupParameter<IItemSet<IClassifier>>("UniqueActions"));
+      Parameters.Add(new ValueLookupParameter<IntValue>("NumberOfUniqueActions"));
     }
+
     public override IOperation Apply() {
       ItemSet<IClassifier> actions = new ItemSet<IClassifier>();
@@ -56,5 +62,6 @@
         actions.Add(classifier.Action);
       }
-      UniqueActionsParameter.Value = actions;
+      UniqueActionsParameter.ActualValue = actions;
+      NumberOfUniqueActionsParameter.ActualValue = new IntValue(actions.Count);
       return base.Apply();
     }
Index: branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/Implementation/ConditionActionClassificationProblem.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/Implementation/ConditionActionClassificationProblem.cs	(revision 9089)
+++ branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/Implementation/ConditionActionClassificationProblem.cs	(revision 9090)
@@ -45,4 +45,10 @@
       get { return (IValueParameter<ConditionActionClassificationProblemData>)Parameters["ProblemData"]; }
     }
+    public IValueParameter<ICoveringSolutionCreator> CoveringSolutionCreatorParameter {
+      get { return (IValueParameter<ICoveringSolutionCreator>)Parameters["CoveringSolutionCreator"]; }
+    }
+    public IFixedValueParameter<PercentValue> ChangeSymbolProbabilityInCoveringParameter {
+      get { return (IFixedValueParameter<PercentValue>)Parameters["ChangeSymbolProbabilityInCovering"]; }
+    }
     public IFixedValueParameter<DoubleValue> PositiveRewardParameter {
       get { return (IFixedValueParameter<DoubleValue>)Parameters["PositiveReward"]; }
@@ -60,8 +66,8 @@
       get { return (IFixedValueParameter<DoubleValue>)Parameters["InitialFitness"]; }
     }
-    public IFixedValueParameter<IItemSet<IClassifier>> PossibleActionsParameter {
-      get { return (IFixedValueParameter<IItemSet<IClassifier>>)Parameters["PossibleActions"]; }
-    }
-    private IFixedValueParameter<IntValue> ThetaMinimalNumberOfActionsParameter {
+    public IFixedValueParameter<ItemSet<IClassifier>> PossibleActionsParameter {
+      get { return (IFixedValueParameter<ItemSet<IClassifier>>)Parameters["PossibleActions"]; }
+    }
+    public IFixedValueParameter<IntValue> ThetaMinimalNumberOfActionsParameter {
       get { return (IFixedValueParameter<IntValue>)Parameters["ThetaMinimalNumberOfActions"]; }
     }
@@ -94,5 +100,5 @@
       get { return PossibleActions; }
     }
-    public IItemSet<IClassifier> PossibleActions {
+    public ItemSet<IClassifier> PossibleActions {
       get { return PossibleActionsParameter.Value; }
     }
@@ -115,4 +121,13 @@
     private IntValue ThetaMinimalNumberOfActions {
       get { return ThetaMinimalNumberOfActionsParameter.Value; }
+    }
+    IParameter IConditionActionProblem.ThetaMinimalNumberOfActionsParameter {
+      get { return ThetaMinimalNumberOfActionsParameter; }
+    }
+    public ICoveringSolutionCreator CoveringSolutionCreator {
+      get { return CoveringSolutionCreatorParameter.Value; }
+    }
+    IParameter IConditionActionProblem.CoveringSolutionCreatorParameter {
+      get { return CoveringSolutionCreatorParameter; }
     }
     #endregion
@@ -130,8 +145,8 @@
       this(new ConditionActionClassificationProblemData(new Dataset(ConditionActionClassificationProblemData.defaultVariableNames, ConditionActionClassificationProblemData.defaultData),
         ConditionActionClassificationProblemData.defaultVariableNames.Take(ConditionActionClassificationProblemData.defaultVariableNames.Length - 1), ConditionActionClassificationProblemData.defaultVariableNames.Last().ToEnumerable()),
-        new XCSEvaluator(), new UniformRandomCombinedIntegerVectorCreator()) {
-    }
-
-    public ConditionActionClassificationProblem(ConditionActionClassificationProblemData problemData, XCSEvaluator evaluator, UniformRandomCombinedIntegerVectorCreator solutionCreator)
+        new XCSEvaluator(), new UniformRandomCombinedIntegerVectorCreator(), new CombinedIntegerVectorCoveringCreator()) {
+    }
+
+    public ConditionActionClassificationProblem(ConditionActionClassificationProblemData problemData, XCSEvaluator evaluator, UniformRandomCombinedIntegerVectorCreator solutionCreator, ICoveringSolutionCreator coveringSolutionCreator)
       : base(evaluator, solutionCreator) {
       Parameters.Add(new FixedValueParameter<IntValue>("Length", "The operator to create a solution.", new IntValue(7)));
@@ -151,4 +166,7 @@
       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 ValueParameter<ICoveringSolutionCreator>("CoveringSolutionCreator", "", coveringSolutionCreator));
+      Parameters.Add(new FixedValueParameter<PercentValue>("ChangeSymbolProbabilityInCovering", "", new PercentValue(0.5)));
+
       Evaluator.InitialErrorParameter.ActualName = "InitialError";
       Evaluator.InitialFitnessParameter.ActualName = "InitialFitness";
@@ -158,4 +176,8 @@
       SolutionCreator.LengthParameter.ActualName = LengthParameter.Name;
       SolutionCreator.BoundsParameter.ActualName = BoundsParameter.Name;
+
+      coveringSolutionCreator.ChangeSymbolProbabilityParameter.ActualName = ChangeSymbolProbabilityInCoveringParameter.Name;
+      coveringSolutionCreator.CoverClassifierParameter.ActualName = ClassifierFetcher.CurrentClassifierToMatchParameter.ActualName;
+      coveringSolutionCreator.CreatedClassifierParameter.ActualName = "CombinedIntegerVector";
 
       ClassifierFetcher.ActionPartLengthParameter.ActualName = ActionPartLengthParameter.Name;
