Index: /branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystem.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystem.cs	(revision 9203)
+++ /branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystem.cs	(revision 9204)
@@ -118,4 +118,10 @@
       get { return (ValueParameter<IntValue>)Parameters["MaxIterations"]; }
     }
+    public IConstrainedValueParameter<ICrossover> CrossoverParameter {
+      get { return (IConstrainedValueParameter<ICrossover>)Parameters["Crossover"]; }
+    }
+    public IConstrainedValueParameter<IManipulator> MutatorParameter {
+      get { return (IConstrainedValueParameter<IManipulator>)Parameters["Mutator"]; }
+    }
     #endregion
 
@@ -204,4 +210,12 @@
       get { return FinalAnalyzerParameter.Value; }
       set { FinalAnalyzerParameter.Value = value; }
+    }
+    public ICrossover Crossover {
+      get { return CrossoverParameter.Value; }
+      set { CrossoverParameter.Value = value; }
+    }
+    public IManipulator Mutator {
+      get { return MutatorParameter.Value; }
+      set { MutatorParameter.Value = value; }
     }
     private RandomCreator RandomCreator {
@@ -237,4 +251,6 @@
       Parameters.Add(new ValueParameter<MultiAnalyzer>("FinalAnalyzer", "The operator used to analyze the last generation.", new MultiAnalyzer()));
       Parameters.Add(new ValueParameter<IntValue>("MaxIterations", "The maximum number of iterations.", new IntValue(1000)));
+      Parameters.Add(new ConstrainedValueParameter<ICrossover>("Crossover", "The operator used to cross solutions."));
+      Parameters.Add(new ConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions."));
       #endregion
 
@@ -256,4 +272,7 @@
       mainLoop.FinalAnalyzerParameter.ActualName = FinalAnalyzerParameter.Name;
       mainLoop.MaxIterationsParameter.ActualName = MaxIterationsParameter.Name;
+      mainLoop.CrossoverParameter.ActualName = CrossoverParameter.Name;
+      mainLoop.MutatorParameter.ActualName = MutatorParameter.Name;
+      mainLoop.CrossoverProbabilityParameter.ActualName = CrossoverProbabilityParameter.Name;
       #endregion
 
@@ -279,7 +298,16 @@
         ParameterizeEvaluator(Problem.Evaluator);
         MainLoop.SetCurrentProblem(Problem);
+        UpdateCrossovers();
+        UpdateMutators();
         UpdateAnalyzers();
+        ParameterizeManipulator();
       }
       base.OnProblemChanged();
+    }
+
+    private void ParameterizeManipulator() {
+      foreach (var op in Problem.Operators.OfType<IProbabilityMutatorOperator>()) {
+        op.ProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
+      }
     }
     protected override void Problem_EvaluatorChanged(object sender, EventArgs e) {
@@ -293,5 +321,8 @@
     }
     protected override void Problem_OperatorsChanged(object sender, EventArgs e) {
+      UpdateCrossovers();
+      UpdateMutators();
       UpdateAnalyzers();
+      ParameterizeManipulator();
       base.Problem_OperatorsChanged(sender, e);
     }
@@ -305,4 +336,35 @@
     }
 
+    private void UpdateCrossovers() {
+      ICrossover oldCrossover = CrossoverParameter.Value;
+      CrossoverParameter.ValidValues.Clear();
+      ICrossover defaultCrossover = Problem.Operators.OfType<ICrossover>().FirstOrDefault();
+
+      foreach (ICrossover crossover in Problem.Operators.OfType<ICrossover>().OrderBy(x => x.Name))
+        CrossoverParameter.ValidValues.Add(crossover);
+
+      if (oldCrossover != null) {
+        ICrossover crossover = CrossoverParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldCrossover.GetType());
+        if (crossover != null) CrossoverParameter.Value = crossover;
+        else oldCrossover = null;
+      }
+      if (oldCrossover == null && defaultCrossover != null)
+        CrossoverParameter.Value = defaultCrossover;
+    }
+    private void UpdateMutators() {
+      IManipulator oldMutator = MutatorParameter.Value;
+      MutatorParameter.ValidValues.Clear();
+      IManipulator defaultMutator = Problem.Operators.OfType<IManipulator>().FirstOrDefault();
+
+      foreach (IManipulator mutator in Problem.Operators.OfType<IManipulator>().OrderBy(x => x.Name))
+        MutatorParameter.ValidValues.Add(mutator);
+      if (oldMutator != null) {
+        IManipulator mutator = MutatorParameter.ValidValues.FirstOrDefault(x => x.GetType() == oldMutator.GetType());
+        if (mutator != null) MutatorParameter.Value = mutator;
+        else oldMutator = null;
+      }
+      if (oldMutator == null && defaultMutator != null)
+        MutatorParameter.Value = defaultMutator;
+    }
     private void UpdateAnalyzers() {
       Analyzer.Operators.Clear();
Index: /branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystemMainLoop.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystemMainLoop.cs	(revision 9203)
+++ /branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystemMainLoop.cs	(revision 9204)
@@ -23,5 +23,4 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Encodings.CombinedIntegerVectorEncoding;
 using HeuristicLab.Encodings.ConditionActionEncoding;
 using HeuristicLab.Operators;
@@ -46,9 +45,12 @@
       get { return (IConstrainedValueParameter<ISelector>)Parameters["Selector"]; }
     }
-    public IConstrainedValueParameter<ICrossover> CrossoverParameter {
-      get { return (IConstrainedValueParameter<ICrossover>)Parameters["Crossover"]; }
-    }
-    public IConstrainedValueParameter<IManipulator> MutatorParameter {
-      get { return (IConstrainedValueParameter<IManipulator>)Parameters["Mutator"]; }
+    public ValueLookupParameter<PercentValue> CrossoverProbabilityParameter {
+      get { return adaptedGeneticAlgorithmMainLoop.CrossoverProbabilityParameter; }
+    }
+    public ValueLookupParameter<IOperator> CrossoverParameter {
+      get { return adaptedGeneticAlgorithmMainLoop.CrossoverParameter; }
+    }
+    public ValueLookupParameter<IOperator> MutatorParameter {
+      get { return adaptedGeneticAlgorithmMainLoop.MutatorParameter; }
     }
     public IConstrainedValueParameter<IOperator> AfterCopyingParentsParameter {
@@ -78,5 +80,5 @@
     private CountNumberOfUniqueActions countNumberOfUniqueActions;
 
-    private UniformSomePositionManipulator test;
+    private LCSAdaptedGeneticAlgorithm adaptedGeneticAlgorithmMainLoop;
 
     private Placeholder evaluator;
@@ -102,10 +104,5 @@
       #region Create parameters
       Parameters.Add(new ConstrainedValueParameter<ISelector>("Selector", "The operator used to select solutions for reproduction.", new ItemSet<ISelector>() { new ProportionalSelector() }, new ProportionalSelector()));
-      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."));
-      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));
       XCSAfterCopyingParentOperator afterCopyingParents = new XCSAfterCopyingParentOperator();
       Parameters.Add(new ConstrainedValueParameter<IOperator>("AfterCopyingParents", "", new ItemSet<IOperator>() { new XCSAfterCopyingParentOperator() }, afterCopyingParents));
@@ -162,5 +159,5 @@
       UniformSubScopesProcessor timestampAssignerSubscopeProcessor = new UniformSubScopesProcessor();
       Assigner timestampAssigner = new Assigner();
-      LCSAdaptedGeneticAlgorithm adaptedGeneticAlgorithmMainLoop = new LCSAdaptedGeneticAlgorithm();
+      adaptedGeneticAlgorithmMainLoop = new LCSAdaptedGeneticAlgorithm();
       IntCounter currentPopulationSizeCounter = new IntCounter();
       CalculateNumberOfDeletionsOperator calculateNumberOfDeletions = new CalculateNumberOfDeletionsOperator();
@@ -313,6 +310,4 @@
 
       adaptedGeneticAlgorithmMainLoop.SelectorParameter.ActualName = SelectorParameter.Name;
-      adaptedGeneticAlgorithmMainLoop.CrossoverParameter.ActualName = CrossoverParameter.Name;
-      adaptedGeneticAlgorithmMainLoop.MutatorParameter.ActualName = MutatorParameter.Name;
       adaptedGeneticAlgorithmMainLoop.RandomParameter.ActualName = "Random";
       adaptedGeneticAlgorithmMainLoop.MaximumGenerationsParameter.ActualName = "ZeroIntValue";
@@ -440,7 +435,4 @@
       classifierFetcher.OperatorParameter.ActualName = problem.ClassifierFetcherParameter.Name;
 
-      test.FetchedConditionParameter.ActualName = problem.ClassifierFetcher.CurrentInputToMatchParameter.ActualName;
-      test.PossibleActionsParameter.ActualName = problem.PossibleActionsConcreteClassParameter.Name;
-
       actionExecuter.OperatorParameter.ActualName = problem.ActionExecuterParameter.Name;
 
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/ILookupParameter.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/ILookupParameter.cs	(revision 9203)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/ILookupParameter.cs	(revision 9204)
@@ -26,4 +26,5 @@
     string ActualName { get; set; }
     string TranslatedName { get; }
+    IExecutionContext ExecutionContext { get; set; }
     event EventHandler ActualNameChanged;
   }
Index: /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IParameter.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IParameter.cs	(revision 9203)
+++ /branches/LearningClassifierSystems/HeuristicLab.Core/3.3/Interfaces/IParameter.cs	(revision 9204)
@@ -27,5 +27,4 @@
     bool Hidden { get; set; }
     IItem ActualValue { get; set; }
-    IExecutionContext ExecutionContext { get; set; }
 
     event EventHandler HiddenChanged;
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/CombinedIntegerVectorManipulator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/CombinedIntegerVectorManipulator.cs	(revision 9203)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/CombinedIntegerVectorManipulator.cs	(revision 9204)
@@ -39,6 +39,6 @@
       get { return (ILookupParameter<CombinedIntegerVector>)Parameters["Child"]; }
     }
-    public ILookupParameter<CombinedIntegerVector> FetchedConditionParameter {
-      get { return (ILookupParameter<CombinedIntegerVector>)Parameters["Parent"]; }
+    public ILookupParameter<CombinedIntegerVector> FetchedInputParameter {
+      get { return (ILookupParameter<CombinedIntegerVector>)Parameters["Input"]; }
     }
     #endregion
@@ -53,13 +53,13 @@
       Parameters.Add(new LookupParameter<IRandom>("Random"));
       Parameters.Add(new LookupParameter<CombinedIntegerVector>("Child"));
-      Parameters.Add(new LookupParameter<CombinedIntegerVector>("Parent"));
+      Parameters.Add(new LookupParameter<CombinedIntegerVector>("Input"));
     }
 
     public sealed override IOperation Apply() {
-      ChildParameter.ActualValue = Manipulate(RandomParameter.ActualValue, FetchedConditionParameter.ActualValue, ChildParameter.ActualValue);
+      ChildParameter.ActualValue = Manipulate(RandomParameter.ActualValue, FetchedInputParameter.ActualValue, ChildParameter.ActualValue);
       return base.Apply();
     }
 
-    protected abstract CombinedIntegerVector Manipulate(IRandom random, CombinedIntegerVector parent, CombinedIntegerVector child);
+    protected abstract CombinedIntegerVector Manipulate(IRandom random, CombinedIntegerVector input, CombinedIntegerVector child);
   }
 }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Covering/CombinedIntegerVectorCoveringCreator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Covering/CombinedIntegerVectorCoveringCreator.cs	(revision 9203)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Covering/CombinedIntegerVectorCoveringCreator.cs	(revision 9204)
@@ -22,8 +22,5 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 using HeuristicLab.Encodings.ConditionActionEncoding;
-using HeuristicLab.Operators;
-using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
@@ -31,24 +28,5 @@
   [Item("CombinedIntegerVectorCoveringCreator", "Description missing")]
   [StorableClass]
-  public class CombinedIntegerVectorCoveringCreator : SingleSuccessorOperator, ICoveringSolutionCreator {
-
-    #region Parameter Properties
-    public ILookupParameter<IInput> CoverInputParameter {
-      get { return (ILookupParameter<IInput>)Parameters["CoverInput"]; }
-    }
-    public ILookupParameter<IAction> ActionParameter {
-      get { return (ILookupParameter<IAction>)Parameters["Action"]; }
-    }
-    public IValueLookupParameter<IClassifier> CreatedClassifierParameter {
-      get { return (IValueLookupParameter<IClassifier>)Parameters["CreatedClassifier"]; }
-    }
-    public ILookupParameter<PercentValue> ChangeSymbolProbabilityParameter {
-      get { return (ILookupParameter<PercentValue>)Parameters["ChangeSymbolProbability"]; }
-    }
-    public ILookupParameter<IRandom> RandomParameter {
-      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
-    }
-
-    #endregion
+  public class CombinedIntegerVectorCoveringCreator : CoveringSolutionCreator, ICombinedIntegerVectorOperator {
 
     [StorableConstructor]
@@ -62,21 +40,15 @@
     public CombinedIntegerVectorCoveringCreator()
       : base() {
-      Parameters.Add(new LookupParameter<IInput>("CoverInput"));
-      Parameters.Add(new LookupParameter<IAction>("Action"));
-      Parameters.Add(new ValueLookupParameter<IClassifier>("CreatedClassifier"));
-      Parameters.Add(new LookupParameter<PercentValue>("ChangeSymbolProbability"));
-      Parameters.Add(new LookupParameter<IRandom>("Random"));
     }
 
-    public override IOperation Apply() {
-      CombinedIntegerVector newCondition = (CombinedIntegerVector)CoverInputParameter.ActualValue.Clone();
+    protected override IClassifier CreateCoveredClassifier(IInput input, IAction action, IRandom random, double changeSymbolProbability) {
+      CombinedIntegerVector newCondition = (CombinedIntegerVector)input.Clone();
 
-      CombinedIntegerVector condition = (CombinedIntegerVector)CoverInputParameter.ActualValue;
-      CombinedIntegerVector action = (CombinedIntegerVector)ActionParameter.ActualValue;
+      CombinedIntegerVector condition = (CombinedIntegerVector)input;
+      CombinedIntegerVector newAction = (CombinedIntegerVector)action;
 
-      newCondition = UniformSomePositionManipulator.ManipulateCondition(RandomParameter.ActualValue, condition, newCondition, ChangeSymbolProbabilityParameter.ActualValue.Value);
+      newCondition = UniformSomePositionManipulator.ManipulateCondition(random, condition, newCondition, changeSymbolProbability);
 
-      CreatedClassifierParameter.ActualValue = new CombinedIntegerVector(newCondition, newCondition.Bounds, action, action.Bounds);
-      return base.Apply();
+      return new CombinedIntegerVector(newCondition, newCondition.Bounds, newAction, newAction.Bounds);
     }
   }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Interfaces/ICombinedIntegerVectorManipulator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Interfaces/ICombinedIntegerVectorManipulator.cs	(revision 9203)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Interfaces/ICombinedIntegerVectorManipulator.cs	(revision 9204)
@@ -29,5 +29,5 @@
   public interface ICombinedIntegerVectorManipulator : IManipulator, ICombinedIntegerVectorOperator {
     ILookupParameter<CombinedIntegerVector> ChildParameter { get; }
-    ILookupParameter<CombinedIntegerVector> FetchedConditionParameter { get; }
+    ILookupParameter<CombinedIntegerVector> FetchedInputParameter { get; }
   }
 }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformActionManipulator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformActionManipulator.cs	(revision 9203)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformActionManipulator.cs	(revision 9204)
@@ -47,10 +47,10 @@
     }
 
-    protected override CombinedIntegerVector Manipulate(IRandom random, CombinedIntegerVector child, CombinedIntegerVector parent) {
-      return Manipulate(random, parent, child, PossibleActionsParameter.ActualValue);
+    protected override CombinedIntegerVector Manipulate(IRandom random, CombinedIntegerVector child, CombinedIntegerVector input) {
+      return Manipulate(random, child, PossibleActionsParameter.ActualValue);
     }
 
-    public static CombinedIntegerVector Manipulate(IRandom random, CombinedIntegerVector parent, CombinedIntegerVector child, IEnumerable<CombinedIntegerVector> possibleActions) {
-      var otherActions = possibleActions.Except(((CombinedIntegerVector)parent.Action).ToEnumerable());
+    public static CombinedIntegerVector Manipulate(IRandom random, CombinedIntegerVector child, IEnumerable<CombinedIntegerVector> possibleActions) {
+      var otherActions = possibleActions.Except(((CombinedIntegerVector)child.Action).ToEnumerable());
       int actionIndex = random.Next(otherActions.Count());
       CombinedIntegerVector newAction = otherActions.ElementAt(actionIndex);
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformOnePositionInConditionManipulator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformOnePositionInConditionManipulator.cs	(revision 9203)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformOnePositionInConditionManipulator.cs	(revision 9204)
@@ -41,12 +41,12 @@
     }
 
-    protected override CombinedIntegerVector Manipulate(IRandom random, CombinedIntegerVector parent, CombinedIntegerVector child) {
-      return Manipulate(parent, child, random.Next(((CombinedIntegerVector)child.Condition).Length));
+    protected override CombinedIntegerVector Manipulate(IRandom random, CombinedIntegerVector input, CombinedIntegerVector child) {
+      return Manipulate(input, child, random.Next(((CombinedIntegerVector)child.Condition).Length));
     }
 
-    public static CombinedIntegerVector Manipulate(CombinedIntegerVector parent, CombinedIntegerVector child, int index) {
+    public static CombinedIntegerVector Manipulate(CombinedIntegerVector input, CombinedIntegerVector child, int index) {
       int max = child.Bounds[index % child.Bounds.Rows, 1] - 1;
       if (child[index].Equals(max)) {
-        child[index] = parent[index];
+        child[index] = input[index];
       } else {
         child[index] = max;
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformSomePositionManipulator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformSomePositionManipulator.cs	(revision 9203)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformSomePositionManipulator.cs	(revision 9204)
@@ -23,9 +23,10 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.ConditionActionEncoding;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Encodings.CombinedIntegerVectorEncoding {
-  public class UniformSomePositionManipulator : CombinedIntegerVectorManipulator {
+  public class UniformSomePositionManipulator : CombinedIntegerVectorManipulator, IProbabilityMutatorOperator {
 
     public IValueLookupParameter<PercentValue> ProbabilityParameter {
@@ -50,18 +51,18 @@
     }
 
-    protected override CombinedIntegerVector Manipulate(IRandom random, CombinedIntegerVector parent, CombinedIntegerVector child) {
-      return Manipulate(random, parent, child, ProbabilityParameter.ActualValue.Value, PossibleActionsParameter.ActualValue);
+    protected override CombinedIntegerVector Manipulate(IRandom random, CombinedIntegerVector input, CombinedIntegerVector child) {
+      return Manipulate(random, input, 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 Manipulate(IRandom random, CombinedIntegerVector input, CombinedIntegerVector child, double probability, IItemSet<CombinedIntegerVector> possibleActions) {
+      child = ManipulateCondition(random, input, child, probability);
+      return ManipulateAction(random, child, probability, possibleActions);
     }
 
-    public static CombinedIntegerVector ManipulateCondition(IRandom random, CombinedIntegerVector parent, CombinedIntegerVector child, double probability) {
+    public static CombinedIntegerVector ManipulateCondition(IRandom random, CombinedIntegerVector input, 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);
+          child = UniformOnePositionInConditionManipulator.Manipulate(input, child, index);
         }
       }
@@ -69,7 +70,7 @@
     }
 
-    public static CombinedIntegerVector ManipulateAction(IRandom random, CombinedIntegerVector parent, CombinedIntegerVector child, double probability, IItemSet<CombinedIntegerVector> possibleActions) {
+    public static CombinedIntegerVector ManipulateAction(IRandom random, CombinedIntegerVector child, double probability, IItemSet<CombinedIntegerVector> possibleActions) {
       if (child.ActionLength > 0 && random.NextDouble() < probability) {
-        UniformActionManipulator.Manipulate(random, parent, child, possibleActions);
+        UniformActionManipulator.Manipulate(random, child, possibleActions);
       }
       return child;
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/CoveringSolutionCreator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/CoveringSolutionCreator.cs	(revision 9204)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/CoveringSolutionCreator.cs	(revision 9204)
@@ -0,0 +1,73 @@
+﻿#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("CoveringSolutionCreator", "Description missing")]
+  [StorableClass]
+  public abstract class CoveringSolutionCreator : SingleSuccessorOperator, ICoveringSolutionCreator {
+
+    #region Parameter Properties
+    public ILookupParameter<IInput> CoverInputParameter {
+      get { return (ILookupParameter<IInput>)Parameters["CoverInput"]; }
+    }
+    public ILookupParameter<IAction> ActionParameter {
+      get { return (ILookupParameter<IAction>)Parameters["Action"]; }
+    }
+    public IValueLookupParameter<IClassifier> CreatedClassifierParameter {
+      get { return (IValueLookupParameter<IClassifier>)Parameters["CreatedClassifier"]; }
+    }
+    public ILookupParameter<PercentValue> ChangeSymbolProbabilityParameter {
+      get { return (ILookupParameter<PercentValue>)Parameters["ChangeSymbolProbability"]; }
+    }
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected CoveringSolutionCreator(bool deserializing) : base(deserializing) { }
+    protected CoveringSolutionCreator(CoveringSolutionCreator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public CoveringSolutionCreator()
+      : base() {
+      Parameters.Add(new LookupParameter<IInput>("CoverInput"));
+      Parameters.Add(new LookupParameter<IAction>("Action"));
+      Parameters.Add(new ValueLookupParameter<IClassifier>("CreatedClassifier"));
+      Parameters.Add(new LookupParameter<PercentValue>("ChangeSymbolProbability"));
+      Parameters.Add(new LookupParameter<IRandom>("Random"));
+    }
+
+    public override IOperation Apply() {
+      CreatedClassifierParameter.ActualValue = CreateCoveredClassifier(CoverInputParameter.ActualValue, ActionParameter.ActualValue, RandomParameter.ActualValue, ChangeSymbolProbabilityParameter.ActualValue.Value);
+      return base.Apply();
+    }
+
+    protected abstract IClassifier CreateCoveredClassifier(IInput input, IAction action, IRandom random, double changeSymbolProbability);
+  }
+}
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 9203)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/HeuristicLab.Encodings.ConditionActionEncoding-3.3.csproj	(revision 9204)
@@ -89,4 +89,5 @@
     <Compile Include="Analyzer\XCSSolutionAnalyzer.cs" />
     <Compile Include="Covering\CoveringOperator.cs" />
+    <Compile Include="Covering\CoveringSolutionCreator.cs" />
     <Compile Include="Covering\DoDeletionBeforeCovering.cs" />
     <Compile Include="Covering\ICovering.cs" />
@@ -107,4 +108,5 @@
     <Compile Include="Interfaces\IXCSModel.cs" />
     <Compile Include="Interfaces\IXCSSolution.cs" />
+    <Compile Include="Manipulator\IProbabilityMutatorOperator.cs" />
     <Compile Include="Operator\CalculateAccuracy.cs" />
     <Compile Include="GA\XCSCheckIfGAShouldBeApplied.cs" />
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionProblem.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionProblem.cs	(revision 9203)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionProblem.cs	(revision 9204)
@@ -35,5 +35,4 @@
     IParameter PossibleActionsConcreteClassParameter { get; }
     IParameter PossibleActionsParameter { get; }
-    //IItemSet<IClassifier> PossibleActions { get; }
 
     IParameter ClassifierComparerParameter { get; }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Manipulator/IProbabilityMutatorOperator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Manipulator/IProbabilityMutatorOperator.cs	(revision 9204)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Manipulator/IProbabilityMutatorOperator.cs	(revision 9204)
@@ -0,0 +1,30 @@
+﻿#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.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Encodings.ConditionActionEncoding {
+  public interface IProbabilityMutatorOperator : IManipulator {
+    IValueLookupParameter<PercentValue> ProbabilityParameter { get; }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Covering/VariableVectorCoveringCreator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Covering/VariableVectorCoveringCreator.cs	(revision 9204)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Covering/VariableVectorCoveringCreator.cs	(revision 9204)
@@ -0,0 +1,76 @@
+﻿#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 System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.ConditionActionEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.VariableVector.Covering {
+  [Item("VariableVectorCoveringCreator", "Description missing")]
+  [StorableClass]
+  public class VariableVectorCoveringCreator : CoveringSolutionCreator, IVariableVectorCoveringCreator {
+
+    public IValueLookupParameter<VariableVector> SampleVariableVectorParameter {
+      get { return (IValueLookupParameter<VariableVector>)Parameters["SampleVariableVector"]; }
+    }
+
+    [StorableConstructor]
+    protected VariableVectorCoveringCreator(bool deserializing) : base(deserializing) { }
+    protected VariableVectorCoveringCreator(VariableVectorCoveringCreator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public VariableVectorCoveringCreator()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<VariableVector>("SampleVariableVector"));
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new VariableVectorCoveringCreator(this, cloner);
+    }
+
+    protected override IClassifier CreateCoveredClassifier(IInput input, IAction action, IRandom random, double changeSymbolProbability) {
+      var inputCast = input as VariableVectorInput;
+      var actionCast = action as VariableVectorAction;
+
+      VariableVectorCondition sampleVariableVectorCondition = SampleVariableVectorParameter.ActualValue.Condition;
+      IEnumerable<IVariable> newCondition = CoverInput(inputCast, sampleVariableVectorCondition, random, changeSymbolProbability);
+
+      return new VariableVector(newCondition, actionCast.Values);
+    }
+
+    private IEnumerable<IVariable> CoverInput(VariableVectorInput input, VariableVectorCondition sample, IRandom random, double changeSymbolProbability) {
+      var conditionVariables = new List<IVariable>();
+      if (!input.Order.SequenceEqual(sample.Order)) {
+        throw new ArgumentException("Sample and input do not contain the same variable names");
+      }
+      foreach (var keyValuePair in sample) {
+        IVariable variable = keyValuePair.Value.GetEmptyCopy();
+        variable.Cover(random, input[keyValuePair.Key].Value, changeSymbolProbability);
+        conditionVariables.Add(variable);
+      }
+      return conditionVariables;
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Crossover/SinglePointCrossover.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Crossover/SinglePointCrossover.cs	(revision 9203)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Crossover/SinglePointCrossover.cs	(revision 9204)
@@ -62,5 +62,5 @@
       IList<IVariable> newCondition = new List<IVariable>(parent1Condition.Count);
 
-      var keyEnumerator = parent1Condition.Keys.GetEnumerator();
+      var keyEnumerator = parent1Condition.Order.GetEnumerator();
 
       int index = 0;
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/HeuristicLab.Encodings.VariableVector-3.3.csproj
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/HeuristicLab.Encodings.VariableVector-3.3.csproj	(revision 9203)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/HeuristicLab.Encodings.VariableVector-3.3.csproj	(revision 9204)
@@ -71,7 +71,14 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Covering\VariableVectorCoveringCreator.cs" />
     <Compile Include="Crossover\SinglePointCrossover.cs" />
+    <Compile Include="Interfaces\IVariableVectorCoveringCreator.cs" />
     <Compile Include="Interfaces\IVariableVectorCrossover.cs" />
+    <Compile Include="Interfaces\IVariableVectorManipulator.cs" />
+    <Compile Include="Manipulator\UniformActionManipulator.cs" />
+    <Compile Include="Manipulator\UniformOnePositionInConditionManipulator.cs" />
+    <Compile Include="Manipulator\UniformSomePositionManipulator.cs" />
     <Compile Include="VariableVectorCrossover.cs" />
+    <Compile Include="VariableVectorManipulator.cs" />
     <Compile Include="Variable\IActionVariable.cs" />
     <Compile Include="Variable\IVariable.cs" />
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Interfaces/IVariableVectorCoveringCreator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Interfaces/IVariableVectorCoveringCreator.cs	(revision 9204)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Interfaces/IVariableVectorCoveringCreator.cs	(revision 9204)
@@ -0,0 +1,29 @@
+﻿#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.Core;
+using HeuristicLab.Encodings.ConditionActionEncoding;
+
+namespace HeuristicLab.Encodings.VariableVector {
+  public interface IVariableVectorCoveringCreator : ICoveringSolutionCreator, IVariableVectorOperator {
+    IValueLookupParameter<VariableVector> SampleVariableVectorParameter { get; }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Interfaces/IVariableVectorManipulator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Interfaces/IVariableVectorManipulator.cs	(revision 9204)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Interfaces/IVariableVectorManipulator.cs	(revision 9204)
@@ -0,0 +1,30 @@
+﻿#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.Core;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Encodings.VariableVector {
+  public interface IVariableVectorManipulator : IManipulator, IVariableVectorOperator {
+    ILookupParameter<VariableVector> ChildParameter { get; }
+    ILookupParameter<VariableVectorInput> FetchedInputParameter { get; }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Manipulator/UniformActionManipulator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Manipulator/UniformActionManipulator.cs	(revision 9204)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Manipulator/UniformActionManipulator.cs	(revision 9204)
@@ -0,0 +1,65 @@
+﻿#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.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.VariableVector {
+  [Item("UniformActionManipulator", "Description missing")]
+  [StorableClass]
+  public class UniformActionManipulator : VariableVectorManipulator {
+
+    #region Parameter Properties
+    public ILookupParameter<IItemSet<VariableVectorAction>> PossibleActionsParameter {
+      get { return (ILookupParameter<IItemSet<VariableVectorAction>>)Parameters["PossibleActions"]; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected UniformActionManipulator(bool deserializing) : base(deserializing) { }
+    protected UniformActionManipulator(UniformActionManipulator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public UniformActionManipulator()
+      : base() {
+      Parameters.Add(new LookupParameter<IItemSet<VariableVectorAction>>("PossibleActions"));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new UniformActionManipulator(this, cloner);
+    }
+
+    protected override VariableVector Manipulate(IRandom random, VariableVectorInput input, VariableVector child) {
+      return Manipulate(random, child, PossibleActionsParameter.ActualValue);
+    }
+
+    public static VariableVector Manipulate(IRandom random, VariableVector child, IEnumerable<VariableVectorAction> possibleActions) {
+      var otherActions = possibleActions.Except((child.Action).ToEnumerable());
+      int actionIndex = random.Next(otherActions.Count());
+      VariableVectorAction newAction = otherActions.ElementAt(actionIndex);
+      return new VariableVector(child.Condition.Values.Select(x => x.GetSetCopy()), newAction.Values.Select(x => x.GetSetCopy()));
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Manipulator/UniformOnePositionInConditionManipulator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Manipulator/UniformOnePositionInConditionManipulator.cs	(revision 9204)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Manipulator/UniformOnePositionInConditionManipulator.cs	(revision 9204)
@@ -0,0 +1,66 @@
+﻿#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.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.VariableVector {
+  [Item("UniformOnePositionInConditionManipulator", "Description missing")]
+  [StorableClass]
+  public class UniformOnePositionInConditionManipulator : VariableVectorManipulator {
+
+    #region Parameter Properties
+    #endregion
+
+    [StorableConstructor]
+    protected UniformOnePositionInConditionManipulator(bool deserializing) : base(deserializing) { }
+    protected UniformOnePositionInConditionManipulator(UniformOnePositionInConditionManipulator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public UniformOnePositionInConditionManipulator()
+      : base() {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new UniformOnePositionInConditionManipulator(this, cloner);
+    }
+
+    protected override VariableVector Manipulate(IRandom random, VariableVectorInput input, VariableVector child) {
+      return Manipulate(random, input, child, random.Next(child.Condition.VirtualLength));
+    }
+
+    public static VariableVector Manipulate(IRandom random, VariableVectorInput input, VariableVector child, int index) {
+      VariableVectorCondition condition = child.Condition;
+      if (index >= condition.VirtualLength) {
+        throw new ArgumentOutOfRangeException();
+      }
+      var keyEnumerator = condition.Order.GetEnumerator();
+      int count = 0;
+      while (keyEnumerator.MoveNext() && count < condition.VirtualLength
+        && count < index && count + condition[keyEnumerator.Current].VirtualLength < index) {
+        count += condition[keyEnumerator.Current].VirtualLength;
+      }
+      condition[keyEnumerator.Current].Manipulate(random, input[keyEnumerator.Current].Value, index - count - 1);
+      return child;
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Manipulator/UniformSomePositionManipulator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Manipulator/UniformSomePositionManipulator.cs	(revision 9204)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Manipulator/UniformSomePositionManipulator.cs	(revision 9204)
@@ -0,0 +1,82 @@
+﻿#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.Encodings.ConditionActionEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.VariableVector {
+  [Item("UniformSomePositionManipulator", "Description missing")]
+  [StorableClass]
+  public class UniformSomePositionManipulator : VariableVectorManipulator, IProbabilityMutatorOperator {
+
+    #region Parameter Properties
+    public IValueLookupParameter<PercentValue> ProbabilityParameter {
+      get { return (IValueLookupParameter<PercentValue>)Parameters["Probability"]; }
+    }
+    public ILookupParameter<IItemSet<VariableVectorAction>> PossibleActionsParameter {
+      get { return (ILookupParameter<IItemSet<VariableVectorAction>>)Parameters["PossibleActions"]; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected UniformSomePositionManipulator(bool deserializing) : base(deserializing) { }
+    protected UniformSomePositionManipulator(UniformSomePositionManipulator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public UniformSomePositionManipulator()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<PercentValue>("Probability", "The probability for each dimension to be manipulated."));
+      Parameters.Add(new LookupParameter<IItemSet<VariableVectorAction>>("PossibleActions"));
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new UniformSomePositionManipulator(this, cloner);
+    }
+
+    protected override VariableVector Manipulate(IRandom random, VariableVectorInput input, VariableVector child) {
+      return Manipulate(random, input, child, ProbabilityParameter.ActualValue.Value, PossibleActionsParameter.ActualValue);
+    }
+
+    public static VariableVector Manipulate(IRandom random, VariableVectorInput input, VariableVector child, double probability, IItemSet<VariableVectorAction> possibleActions) {
+      child = ManipulateCondition(random, input, child, probability);
+      return ManipulateAction(random, child, probability, possibleActions);
+    }
+
+    public static VariableVector ManipulateCondition(IRandom random, VariableVectorInput input, VariableVector child, double probability) {
+      for (int index = 0; index < child.Condition.VirtualLength; index++) {
+        if (random.NextDouble() < probability) {
+          child = UniformOnePositionInConditionManipulator.Manipulate(random, input, child, index);
+        }
+      }
+      return child;
+    }
+
+    public static VariableVector ManipulateAction(IRandom random, VariableVector child, double probability, IItemSet<VariableVectorAction> possibleActions) {
+      if (random.NextDouble() < probability) {
+        UniformActionManipulator.Manipulate(random, child, possibleActions);
+      }
+      return child;
+    }
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Plugin.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Plugin.cs	(revision 9204)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Plugin.cs	(revision 9204)
@@ -0,0 +1,31 @@
+﻿#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.PluginInfrastructure;
+
+namespace HeuristicLab.Encodings.VariableVector {
+  [Plugin("HeuristicLab.Encodings.VariableVector", "3.3.7.9194")]
+  [PluginFile("HeuristicLab.Encodings.VariableVector-3.3.dll", PluginFileType.Assembly)]
+  [PluginDependency("HeuristicLab.Common.Resources", "3.3")]
+  [PluginDependency("HeuristicLab.Data", "3.3")]
+  public class HeuristicLabEncodingsVariableVectorPlugin : PluginBase {
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Properties/AssemblyInfo.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Properties/AssemblyInfo.cs	(revision 9204)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Properties/AssemblyInfo.cs	(revision 9204)
@@ -0,0 +1,57 @@
+﻿#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.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("HeuristicLab.Encodings.VariableVector-3.3")]
+[assembly: AssemblyDescription("Encoding with variables")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("HEAL")]
+[assembly: AssemblyProduct("HeuristicLab")]
+[assembly: AssemblyCopyright("(c) 2002-2012 HEAL")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("d591186d-c10f-42ea-bc8f-a079a978e793")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("3.3.0.0")]
+[assembly: AssemblyFileVersion("3.3.7.9194")]
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/DoubleVariable.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/DoubleVariable.cs	(revision 9203)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/DoubleVariable.cs	(revision 9204)
@@ -137,6 +137,6 @@
     public override double GetGenerality() {
       double delta = max - min;
-      double intervalWidth = 2 * currentSpread;
-      double generality = intervalWidth / delta;
+      double intervalInBoundsWidth = Math.Min(max, currentCenter + currentSpread) - Math.Max(min, currentCenter - currentSpread);
+      double generality = intervalInBoundsWidth / delta;
       return generality > 1 ? 1 : generality;
     }
@@ -159,4 +159,33 @@
       return crossed;
     }
+
+    public override void Manipulate(IRandom random, string stringValue, int pos) {
+      if (pos > 1 || pos < 0) { throw new ArgumentOutOfRangeException(); }
+      Manipulate(random, pos, 10);
+    }
+
+    public void Manipulate(IRandom random, int pos, double percentage) {
+      if (pos > 1 || pos < 0) { throw new ArgumentOutOfRangeException(); }
+      double delta = max - min;
+      double maxChange = delta * (percentage / 100);
+      double actualChange = (random.NextDouble() * maxChange * 2) - maxChange;
+      if (pos == 0) {
+        currentCenter += actualChange;
+      } else if (pos == 1) {
+        currentSpread += actualChange;
+        //otherwise the interval could be corrupt and no input could match the rule.
+        currentSpread = currentSpread > 0 ? currentSpread : 0;
+      }
+    }
+
+    public override void Cover(IRandom random, string stringValue, double changeSymbolProbability) {
+      Cover(random, stringValue, 50);
+    }
+
+    public void CoverWithSpreadPercentage(IRandom random, string stringValue, double spreadPercentage) {
+      currentCenter = double.Parse(stringValue);
+      double delta = max - min;
+      currentSpread = random.NextDouble() * (delta * (spreadPercentage / 100));
+    }
   }
 }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IVariable.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IVariable.cs	(revision 9203)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IVariable.cs	(revision 9204)
@@ -41,4 +41,8 @@
 
     IVariable CrossParentsAtPosition(IVariable parent2, int pos);
+
+    void Manipulate(IRandom random, string stringValue, int pos);
+
+    void Cover(IRandom random, string stringValue, double changeSymbolProbability);
   }
 }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IntVariable.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IntVariable.cs	(revision 9203)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IntVariable.cs	(revision 9204)
@@ -86,5 +86,5 @@
 
     public override string ToString() {
-      return currentValue.ToString();
+      return Wildcard ? "#" : currentValue.ToString();
     }
 
@@ -145,4 +145,19 @@
       return this.GetSetCopy();
     }
+
+    public override void Manipulate(IRandom random, string stringValue, int pos) {
+      if (pos != 0) { throw new ArgumentOutOfRangeException(); }
+      Wildcard = !Wildcard;
+      if (!Wildcard) {
+        currentValue = int.Parse(stringValue);
+      }
+    }
+
+    public override void Cover(IRandom random, string stringValue, double changeSymbolProbability) {
+      Wildcard = random.NextDouble() < changeSymbolProbability;
+      if (!Wildcard) {
+        currentValue = int.Parse(stringValue);
+      }
+    }
   }
 }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/StringVariable.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/StringVariable.cs	(revision 9203)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/StringVariable.cs	(revision 9204)
@@ -134,5 +134,5 @@
 
     public override string ToString() {
-      return CurrentStringValue;
+      return Wildcard ? "#" : CurrentStringValue;
     }
 
@@ -197,4 +197,21 @@
       return this.GetSetCopy();
     }
+
+    public override void Manipulate(IRandom random, string stringValue, int pos) {
+      if (pos != 0) { throw new ArgumentOutOfRangeException(); }
+      Wildcard = !Wildcard;
+      if (!Wildcard) {
+        int newValue = featureMapping.First(x => x.Value.Equals(stringValue)).Key;
+        currentValue = newValue;
+      }
+    }
+
+    public override void Cover(IRandom random, string stringValue, double changeSymbolProbability) {
+      Wildcard = random.NextDouble() < changeSymbolProbability;
+      if (!Wildcard) {
+        int newValue = featureMapping.First(x => x.Value.Equals(stringValue)).Key;
+        currentValue = newValue;
+      }
+    }
   }
 }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/Variable.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/Variable.cs	(revision 9203)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/Variable.cs	(revision 9204)
@@ -69,4 +69,8 @@
 
     public virtual IVariable CrossParentsAtPosition(IVariable parent2, int pos) { throw new NotSupportedException("This method is not supported."); }
+
+    public abstract void Manipulate(IRandom random, string stringValue, int pos);
+
+    public abstract void Cover(IRandom random, string stringValue, double changeSymbolProbability);
   }
 }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVector.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVector.cs	(revision 9203)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVector.cs	(revision 9204)
@@ -33,4 +33,5 @@
   [Item("VariableVector", "")]
   public class VariableVector : Item, IClassifier {
+
     [Storable]
     protected VariableVectorCondition condition;
@@ -131,4 +132,38 @@
       return true;
     }
+
+    [StorableClass]
+    [Item("VariableVectorActionComparer", "")]
+    public class VariableVectorActionComparer : Item, IEqualityComparer<VariableVectorAction>, IClassifierComparer {
+
+      [StorableConstructor]
+      protected VariableVectorActionComparer(bool deserializing) : base(deserializing) { }
+      protected VariableVectorActionComparer(VariableVectorActionComparer original, Cloner cloner)
+        : base(original, cloner) {
+      }
+      public override IDeepCloneable Clone(Cloner cloner) {
+        return new VariableVectorActionComparer(this, cloner);
+      }
+      public VariableVectorActionComparer() : base() { }
+
+      public bool Equals(VariableVectorAction x, VariableVectorAction y) {
+        throw new NotImplementedException();
+      }
+
+      public int GetHashCode(VariableVectorAction obj) {
+        throw new NotImplementedException();
+      }
+
+      public bool Equals(IAction x, IAction y) {
+        var xCast = x as VariableVectorAction;
+        var yCast = y as VariableVectorAction;
+        return x != null && y != null && Equals(xCast, yCast);
+      }
+
+      public int GetHashCode(IAction obj) {
+        var objCast = obj as VariableVectorAction;
+        return objCast != null ? GetHashCode(objCast) : obj.GetHashCode();
+      }
+    }
   }
 }
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorAction.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorAction.cs	(revision 9203)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorAction.cs	(revision 9204)
@@ -35,4 +35,6 @@
   public class VariableVectorAction : ItemDictionary<StringValue, IActionVariable>, IAction {
 
+    public IOrderedEnumerable<StringValue> Order { get { return this.Keys.OrderBy(x => x.Value); } }
+
     public int VirtualLength { get { return this.Values.Sum(x => x.VirtualLength); } }
 
@@ -61,5 +63,5 @@
       var targetCast = target as VariableVectorAction;
       if (targetCast == null) { return false; }
-      if (!(this.Keys.Except(targetCast.Keys).Count() == 0 && targetCast.Keys.Except(this.Keys).Count() == 0)) { return false; }
+      if (this.Order.SequenceEqual(targetCast.Order)) { return false; }
       foreach (var keyValuePair in targetCast) {
         if (!this[keyValuePair.Key].MatchVariable(keyValuePair.Value)) {
@@ -97,5 +99,5 @@
 
     public bool Identical(VariableVectorCondition target) {
-      if (!(target.Keys.Except(this.Keys).Count() == 0 && this.Keys.Except(target.Keys).Count() == 0)) { return false; }
+      if (this.Order.SequenceEqual(target.Order)) { return false; }
       foreach (var keyValuePair in target) {
         if (!this[keyValuePair.Key].Identical(keyValuePair.Value)) {
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorCondition.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorCondition.cs	(revision 9203)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorCondition.cs	(revision 9204)
@@ -34,4 +34,6 @@
   public class VariableVectorCondition : ItemDictionary<StringValue, IVariable>, ICondition {
 
+    public IOrderedEnumerable<StringValue> Order { get { return this.Keys.OrderBy(x => x.Value); } }
+
     public int VirtualLength { get { return this.Values.Sum(x => x.VirtualLength); } }
 
@@ -51,5 +53,5 @@
       var targetCast = target as VariableVectorInput;
       if (targetCast == null) { return false; }
-      if (!(targetCast.Keys.Except(this.Keys).Count() == 0 && this.Keys.Except(targetCast.Keys).Count() == 0)) { return false; }
+      if (this.Order.SequenceEqual(targetCast.Order)) { return false; }
       foreach (var keyValuePair in targetCast) {
         if (!this[keyValuePair.Key].MatchInput(keyValuePair.Value.Value)) {
@@ -91,5 +93,5 @@
 
     public bool Identical(VariableVectorCondition target) {
-      if (!(target.Keys.Except(this.Keys).Count() == 0 && this.Keys.Except(target.Keys).Count() == 0)) { return false; }
+      if (this.Order.SequenceEqual(target.Order)) { return false; }
       foreach (var keyValuePair in target) {
         if (!this[keyValuePair.Key].Identical(keyValuePair.Value)) {
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorInput.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorInput.cs	(revision 9203)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorInput.cs	(revision 9204)
@@ -21,4 +21,5 @@
 
 using System.Collections.Generic;
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -31,4 +32,6 @@
   [Item("VariableVectorInput", "")]
   public class VariableVectorInput : ItemDictionary<StringValue, StringValue>, IInput {
+
+    public IOrderedEnumerable<StringValue> Order { get { return this.Keys.OrderBy(x => x.Value); } }
 
     [StorableConstructor]
Index: /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorManipulator.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorManipulator.cs	(revision 9204)
+++ /branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorManipulator.cs	(revision 9204)
@@ -0,0 +1,65 @@
+﻿#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.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.VariableVector {
+  [Item("VariableVectorManipulator", "Description missing")]
+  [StorableClass]
+  public abstract class VariableVectorManipulator : SingleSuccessorOperator, IVariableVectorManipulator, IStochasticOperator {
+
+    #region parameters
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<VariableVector> ChildParameter {
+      get { return (ILookupParameter<VariableVector>)Parameters["Child"]; }
+    }
+    public ILookupParameter<VariableVectorInput> FetchedInputParameter {
+      get { return (ILookupParameter<VariableVectorInput>)Parameters["Input"]; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected VariableVectorManipulator(bool deserializing) : base(deserializing) { }
+    protected VariableVectorManipulator(VariableVectorManipulator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public VariableVectorManipulator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random"));
+      Parameters.Add(new LookupParameter<VariableVector>("Child"));
+      Parameters.Add(new LookupParameter<VariableVectorInput>("Input"));
+    }
+
+    public sealed override IOperation Apply() {
+      ChildParameter.ActualValue = Manipulate(RandomParameter.ActualValue, FetchedInputParameter.ActualValue, ChildParameter.ActualValue);
+      return base.Apply();
+    }
+
+    protected abstract VariableVector Manipulate(IRandom random, VariableVectorInput input, VariableVector child);
+  }
+}
Index: /branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/Implementation/ConditionActionClassificationProblem.cs
===================================================================
--- /branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/Implementation/ConditionActionClassificationProblem.cs	(revision 9203)
+++ /branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/Implementation/ConditionActionClassificationProblem.cs	(revision 9204)
@@ -20,4 +20,5 @@
 #endregion
 
+using System.Collections.Generic;
 using System.Linq;
 using HeuristicLab.Common;
@@ -29,4 +30,5 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
 using HeuristicLab.Problems.DataAnalysis;
 using HeuristicLab.Problems.Instances;
@@ -233,12 +235,22 @@
 
     private void InitializeOperators() {
+      Operators.AddRange(ApplicationManager.Manager.GetInstances<ICombinedIntegerVectorCrossover>());
+      Operators.AddRange(AddManipulators());
       Operators.Add(new BestTrainingXCSSolutionAnalyzer());
       Operators.Add(new CurrentXCSSolutionAnalyzer());
 
-      ParameterizeAnalyzers();
-    }
-
-    private void ParameterizeAnalyzers() {
-      foreach (XCSSolutionAnalyzer xcsAnalyzer in Operators.Where(x => x is XCSSolutionAnalyzer)) {
+      ParameterizeOperators();
+    }
+
+    private IEnumerable<ICombinedIntegerVectorManipulator> AddManipulators() {
+      var manipulator = new UniformSomePositionManipulator();
+      manipulator.ChildParameter.ActualName = "CombinedIntegerVector";
+      manipulator.FetchedInputParameter.ActualName = ClassifierFetcher.CurrentInputToMatchParameter.ActualName;
+      manipulator.PossibleActionsParameter.ActualName = PossibleActionsConcreteClassParameter.Name;
+      return new List<ICombinedIntegerVectorManipulator>() { manipulator };
+    }
+
+    private void ParameterizeOperators() {
+      foreach (XCSSolutionAnalyzer xcsAnalyzer in Operators.OfType<XCSSolutionAnalyzer>()) {
         xcsAnalyzer.ClassifierParameter.ActualName = SolutionCreator.CombinedIntegerVectorParameter.ActualName;
         xcsAnalyzer.PredictionParameter.ActualName = Evaluator.PredictionParameter.ActualName;
