Index: branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/HeuristicLab.Algorithms.LearningClassifierSystems-3.3.csproj
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/HeuristicLab.Algorithms.LearningClassifierSystems-3.3.csproj	(revision 8941)
+++ branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/HeuristicLab.Algorithms.LearningClassifierSystems-3.3.csproj	(revision 9089)
@@ -96,13 +96,9 @@
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="ActionSelection\ActionSelector.cs" />
-    <Compile Include="ActionSelection\MaxValueActionSelector.cs" />
-    <Compile Include="ActionSelection\RandomActionSelector.cs" />
+    <Compile Include="LCSAdaptedGeneticAlgorithm.cs" />
     <Compile Include="LearningClassifierSystem.cs" />
     <Compile Include="LearningClassifierSystemMainLoop.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Plugin.cs" />
-    <Compile Include="Selectors\IMatchSelector.cs" />
-    <Compile Include="Selectors\MatchSelector.cs" />
     <None Include="Properties\AssemblyInfo.cs.frame" />
   </ItemGroup>
@@ -115,4 +111,12 @@
       <Project>{CE7163C5-BFFE-45F0-9BD0-E10EF24E8BD2}</Project>
       <Name>HeuristicLab.Encodings.CombinedIntegerVectorEncoding-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Encodings.ConditionActionEncoding\3.3\HeuristicLab.Encodings.ConditionActionEncoding-3.3.csproj">
+      <Project>{422FB262-0845-4969-8D16-12F057AA90B1}</Project>
+      <Name>HeuristicLab.Encodings.ConditionActionEncoding-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Problems.ConditionActionClassification\3.3\HeuristicLab.Problems.ConditionActionClassification-3.3.csproj">
+      <Project>{EA51D441-F6A3-41E1-9993-A2488E93C222}</Project>
+      <Name>HeuristicLab.Problems.ConditionActionClassification-3.3</Name>
     </ProjectReference>
   </ItemGroup>
Index: branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LCSAdaptedGeneticAlgorithm.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LCSAdaptedGeneticAlgorithm.cs	(revision 9089)
+++ branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LCSAdaptedGeneticAlgorithm.cs	(revision 9089)
@@ -0,0 +1,230 @@
+﻿#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.Optimization.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Selection;
+namespace HeuristicLab.Algorithms.LearningClassifierSystems {
+  /// <summary>
+  /// An operator which represents the main loop of a genetic algorithm.
+  /// </summary>
+  [Item("LCSAdaptedGeneticAlgorithm", "An operator which represents the main loop of a genetic algorithm, which has been adapdet for learning classifier systems.")]
+  [StorableClass]
+  public sealed class LCSAdaptedGeneticAlgorithm : AlgorithmOperator {
+    #region Parameter properties
+    public ValueLookupParameter<IRandom> RandomParameter {
+      get { return (ValueLookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (ValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public ValueLookupParameter<IOperator> SelectorParameter {
+      get { return (ValueLookupParameter<IOperator>)Parameters["Selector"]; }
+    }
+    public ValueLookupParameter<IOperator> CrossoverParameter {
+      get { return (ValueLookupParameter<IOperator>)Parameters["Crossover"]; }
+    }
+    public ValueLookupParameter<PercentValue> MutationProbabilityParameter {
+      get { return (ValueLookupParameter<PercentValue>)Parameters["MutationProbability"]; }
+    }
+    public ValueLookupParameter<IOperator> MutatorParameter {
+      get { return (ValueLookupParameter<IOperator>)Parameters["Mutator"]; }
+    }
+    public ValueLookupParameter<IntValue> MaximumGenerationsParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["MaximumGenerations"]; }
+    }
+    public ValueLookupParameter<VariableCollection> ResultsParameter {
+      get { return (ValueLookupParameter<VariableCollection>)Parameters["Results"]; }
+    }
+    public ValueLookupParameter<IOperator> AnalyzerParameter {
+      get { return (ValueLookupParameter<IOperator>)Parameters["Analyzer"]; }
+    }
+    public ValueLookupParameter<IntValue> EvaluatedSolutionsParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["EvaluatedSolutions"]; }
+    }
+    public ValueLookupParameter<IntValue> PopulationSizeParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["PopulationSize"]; }
+    }
+    private ScopeParameter CurrentScopeParameter {
+      get { return (ScopeParameter)Parameters["CurrentScope"]; }
+    }
+
+    public IScope CurrentScope {
+      get { return CurrentScopeParameter.ActualValue; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    private LCSAdaptedGeneticAlgorithm(bool deserializing) : base(deserializing) { }
+    private LCSAdaptedGeneticAlgorithm(LCSAdaptedGeneticAlgorithm original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new LCSAdaptedGeneticAlgorithm(this, cloner);
+    }
+    public LCSAdaptedGeneticAlgorithm()
+      : base() {
+      Initialize();
+    }
+
+    private void Initialize() {
+      #region Create parameters
+      Parameters.Add(new ValueLookupParameter<IRandom>("Random", "A pseudo random number generator."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("Selector", "The operator used to select solutions for reproduction."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("Crossover", "The operator used to cross solutions."));
+      Parameters.Add(new ValueLookupParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("Mutator", "The operator used to mutate solutions."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("MaximumGenerations", "The maximum number of generations which should be processed."));
+      Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The variable collection where results should be stored."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to analyze each generation."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("EvaluatedSolutions", "The number of times solutions have been evaluated."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("PopulationSize", "The size of the population."));
+      Parameters.Add(new ScopeParameter("CurrentScope", "The current scope which represents a population of solutions on which the genetic algorithm should be applied."));
+      #endregion
+
+      #region Create operators
+      VariableCreator variableCreator = new VariableCreator();
+      ResultsCollector resultsCollector1 = new ResultsCollector();
+      Placeholder analyzer1 = new Placeholder();
+      Placeholder selector = new Placeholder();
+      SubScopesProcessor subScopesProcessor1 = new SubScopesProcessor();
+      ChildrenCreator childrenCreator = new ChildrenCreator();
+      UniformSubScopesProcessor uniformSubScopesProcessor1 = new UniformSubScopesProcessor();
+      Placeholder crossover = new Placeholder();
+      DataReducer dataReducer = new DataReducer();
+      StochasticBranch stochasticBranch = new StochasticBranch();
+      Placeholder mutator = new Placeholder();
+      SubScopesRemover subScopesRemover = new SubScopesRemover();
+      SubScopesCounter subScopesCounter = new SubScopesCounter();
+      SubScopesProcessor subScopesProcessor2 = new SubScopesProcessor();
+      BestSelector bestSelector = new BestSelector();
+      RightReducer rightReducer = new RightReducer();
+      MergingReducer mergingReducer = new MergingReducer();
+      IntCounter intCounter = new IntCounter();
+      Comparator comparator = new Comparator();
+      Placeholder analyzer2 = new Placeholder();
+      ConditionalBranch conditionalBranch = new ConditionalBranch();
+
+      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Generations", new IntValue(0))); // Class GeneticAlgorithm expects this to be called Generations
+
+      resultsCollector1.CollectedValues.Add(new LookupParameter<IntValue>("Generations"));
+      resultsCollector1.ResultsParameter.ActualName = "Results";
+
+      analyzer1.Name = "Analyzer";
+      analyzer1.OperatorParameter.ActualName = "Analyzer";
+
+      selector.Name = "Selector";
+      selector.OperatorParameter.ActualName = "Selector";
+
+      childrenCreator.ParentsPerChild = new IntValue(2);
+
+      crossover.Name = "Crossover";
+      crossover.OperatorParameter.ActualName = "Crossover";
+
+      dataReducer.Name = "Average Fitness of Parents";
+      dataReducer.ParameterToReduce.ActualName = "Fitness";
+      dataReducer.ReductionOperation.Value = new ReductionOperation(ReductionOperations.Avg);
+      dataReducer.TargetParameter.ActualName = "Fitness";
+      dataReducer.TargetOperation.Value = new ReductionOperation(ReductionOperations.Assign);
+
+      stochasticBranch.ProbabilityParameter.ActualName = "MutationProbability";
+      stochasticBranch.RandomParameter.ActualName = "Random";
+
+      mutator.Name = "Mutator";
+      mutator.OperatorParameter.ActualName = "Mutator";
+
+      subScopesRemover.RemoveAllSubScopes = true;
+
+      subScopesCounter.Name = "Increment EvaluatedSolutions";
+      subScopesCounter.ValueParameter.ActualName = EvaluatedSolutionsParameter.Name;
+
+      bestSelector.CopySelected = new BoolValue(false);
+      bestSelector.MaximizationParameter.ActualName = "Maximization";
+      bestSelector.NumberOfSelectedSubScopesParameter.ActualName = "N";
+      bestSelector.QualityParameter.ActualName = "Fitness";
+
+      intCounter.Increment = new IntValue(1);
+      intCounter.ValueParameter.ActualName = "Generations";
+
+      comparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
+      comparator.LeftSideParameter.ActualName = "Generations";
+      comparator.ResultParameter.ActualName = "Terminate";
+      comparator.RightSideParameter.ActualName = "MaximumGenerations";
+
+      analyzer2.Name = "Analyzer";
+      analyzer2.OperatorParameter.ActualName = "Analyzer";
+
+      conditionalBranch.ConditionParameter.ActualName = "Terminate";
+      #endregion
+
+      #region Create operator graph
+      OperatorGraph.InitialOperator = variableCreator;
+      variableCreator.Successor = resultsCollector1;
+      resultsCollector1.Successor = analyzer1;
+      analyzer1.Successor = selector;
+      selector.Successor = subScopesProcessor1;
+      subScopesProcessor1.Operators.Add(new EmptyOperator());
+      subScopesProcessor1.Operators.Add(childrenCreator);
+      subScopesProcessor1.Successor = subScopesProcessor2;
+      childrenCreator.Successor = uniformSubScopesProcessor1;
+      uniformSubScopesProcessor1.Operator = crossover;
+      uniformSubScopesProcessor1.Successor = subScopesCounter;
+      crossover.Successor = dataReducer;
+      dataReducer.Successor = stochasticBranch;
+      stochasticBranch.FirstBranch = mutator;
+      stochasticBranch.SecondBranch = null;
+      stochasticBranch.Successor = subScopesRemover;
+      mutator.Successor = null;
+      subScopesRemover.Successor = null;
+      subScopesCounter.Successor = null;
+      subScopesProcessor2.Operators.Add(bestSelector);
+      subScopesProcessor2.Operators.Add(new EmptyOperator());
+      subScopesProcessor2.Successor = mergingReducer;
+      bestSelector.Successor = rightReducer;
+      rightReducer.Successor = null;
+      mergingReducer.Successor = intCounter;
+      intCounter.Successor = comparator;
+      comparator.Successor = analyzer2;
+      analyzer2.Successor = conditionalBranch;
+      conditionalBranch.FalseBranch = selector;
+      conditionalBranch.TrueBranch = null;
+      conditionalBranch.Successor = null;
+      #endregion
+    }
+
+    public override IOperation Apply() {
+      if (CrossoverParameter.ActualValue == null)
+        return null;
+      return base.Apply();
+    }
+  }
+}
Index: branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystem.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystem.cs	(revision 8941)
+++ branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystem.cs	(revision 9089)
@@ -24,8 +24,6 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Encodings.CombinedIntegerVectorEncoding;
-using HeuristicLab.Operators;
+using HeuristicLab.Encodings.ConditionActionEncoding;
 using HeuristicLab.Optimization;
-using HeuristicLab.Optimization.Operators;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -39,13 +37,13 @@
   [Creatable("Algorithms")]
   [StorableClass]
-  public class LearningClassifierSystem : HeuristicOptimizationEngineAlgorithm, IStorableContent {
+  public sealed class LearningClassifierSystem : HeuristicOptimizationEngineAlgorithm, IStorableContent {
     public string Filename { get; set; }
 
     #region Problem Properties
     public override Type ProblemType {
-      get { return typeof(ISingleObjectiveHeuristicOptimizationProblem); }
-    }
-    public new ISingleObjectiveHeuristicOptimizationProblem Problem {
-      get { return (ISingleObjectiveHeuristicOptimizationProblem)base.Problem; }
+      get { return typeof(IConditionActionProblem); }
+    }
+    public new IConditionActionProblem Problem {
+      get { return (IConditionActionProblem)base.Problem; }
       set { base.Problem = value; }
     }
@@ -59,19 +57,51 @@
       get { return (ValueParameter<BoolValue>)Parameters["SetSeedRandomly"]; }
     }
+    private ValueParameter<BoolValue> CreateInitialPopulationParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["CreateInitialPopulation"]; }
+    }
     private ValueParameter<IntValue> PopulationSizeParameter {
-      get { return (ValueParameter<IntValue>)Parameters["PopulationSize"]; }
-    }
-    //for test purpose
-    public ValueParameter<ICombinedIntegerVectorCreator> SolutionCreatorParameter {
-      get { return (ValueParameter<ICombinedIntegerVectorCreator>)Parameters["SolutionCreator"]; }
-    }
-    public ValueParameter<IntValue> Length {
-      get { return (ValueParameter<IntValue>)Parameters["Length"]; }
-    }
-    public ValueParameter<IntValue> ActionPartLength {
-      get { return (ValueParameter<IntValue>)Parameters["ActionPartLength"]; }
-    }
-    public ValueParameter<IntMatrix> Bounds {
-      get { return (ValueParameter<IntMatrix>)Parameters["Bounds"]; }
+      get { return (ValueParameter<IntValue>)Parameters["N"]; }
+    }
+    private ValueParameter<PercentValue> BetaParameter {
+      get { return (ValueParameter<PercentValue>)Parameters["Beta"]; }
+    }
+    private ValueParameter<PercentValue> AlphaParameter {
+      get { return (ValueParameter<PercentValue>)Parameters["Alpha"]; }
+    }
+    private ValueParameter<DoubleValue> ErrorZeroParameter {
+      get { return (ValueParameter<DoubleValue>)Parameters["ErrorZero"]; }
+    }
+    private ValueParameter<DoubleValue> PowerParameter {
+      get { return (ValueParameter<DoubleValue>)Parameters["v"]; }
+    }
+    private ValueParameter<PercentValue> GammaParameter {
+      get { return (ValueParameter<PercentValue>)Parameters["Gamma"]; }
+    }
+    private ValueParameter<PercentValue> CrossoverProbabilityParameter {
+      get { return (ValueParameter<PercentValue>)Parameters["CrossoverProbability"]; }
+    }
+    private ValueParameter<PercentValue> MutationProbabilityParameter {
+      get { return (ValueParameter<PercentValue>)Parameters["MutationProbability"]; }
+    }
+    private ValueParameter<IntValue> ThetaGAParameter {
+      get { return (ValueParameter<IntValue>)Parameters["ThetaGA"]; }
+    }
+    private ValueParameter<IntValue> ThetaDeletionParameter {
+      get { return (ValueParameter<IntValue>)Parameters["ThetaDeletion"]; }
+    }
+    private ValueParameter<IntValue> ThetaSubsumptionParameter {
+      get { return (ValueParameter<IntValue>)Parameters["ThetaSubsumption"]; }
+    }
+    private ValueParameter<PercentValue> DeltaParameter {
+      get { return (ValueParameter<PercentValue>)Parameters["Delta"]; }
+    }
+    private ValueParameter<PercentValue> ExplorationProbabilityParameter {
+      get { return (ValueParameter<PercentValue>)Parameters["ExplorationProbability"]; }
+    }
+    private ValueParameter<BoolValue> DoGASubsumptionParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["DoGASubsumption"]; }
+    }
+    private ValueParameter<BoolValue> DoActionSetSubsumptionParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["DoActionSetSubsumption"]; }
     }
     #endregion
@@ -86,9 +116,74 @@
       set { SetSeedRandomlyParameter.Value = value; }
     }
+    public BoolValue CreateInitialPopulation {
+      get { return CreateInitialPopulationParameter.Value; }
+      set { CreateInitialPopulationParameter.Value = value; }
+    }
     public IntValue PopulationSize {
       get { return PopulationSizeParameter.Value; }
       set { PopulationSizeParameter.Value = value; }
     }
-
+    public PercentValue Beta {
+      get { return BetaParameter.Value; }
+      set { BetaParameter.Value = value; }
+    }
+    public PercentValue Alpha {
+      get { return AlphaParameter.Value; }
+      set { AlphaParameter.Value = value; }
+    }
+    public DoubleValue ErrorZero {
+      get { return ErrorZeroParameter.Value; }
+      set { ErrorZeroParameter.Value = value; }
+    }
+    public DoubleValue Power {
+      get { return PowerParameter.Value; }
+      set { PowerParameter.Value = value; }
+    }
+    public PercentValue Gamma {
+      get { return GammaParameter.Value; }
+      set { GammaParameter.Value = value; }
+    }
+    public PercentValue CrossoverProbability {
+      get { return CrossoverProbabilityParameter.Value; }
+      set { CrossoverProbabilityParameter.Value = value; }
+    }
+    public PercentValue MutationProbability {
+      get { return MutationProbabilityParameter.Value; }
+      set { MutationProbabilityParameter.Value = value; }
+    }
+    public IntValue ThetaGA {
+      get { return ThetaGAParameter.Value; }
+      set { ThetaGAParameter.Value = value; }
+    }
+    public IntValue ThetaDeletion {
+      get { return ThetaDeletionParameter.Value; }
+      set { ThetaDeletionParameter.Value = value; }
+    }
+    public IntValue ThetaSubsumption {
+      get { return ThetaSubsumptionParameter.Value; }
+      set { ThetaSubsumptionParameter.Value = value; }
+    }
+    public PercentValue Delta {
+      get { return DeltaParameter.Value; }
+      set { DeltaParameter.Value = value; }
+    }
+    public PercentValue ExplorationProbability {
+      get { return ExplorationProbabilityParameter.Value; }
+      set { ExplorationProbabilityParameter.Value = value; }
+    }
+    public BoolValue DoGASubsumption {
+      get { return DoGASubsumptionParameter.Value; }
+      set { DoGASubsumptionParameter.Value = value; }
+    }
+    public BoolValue DoActionSetSubsumption {
+      get { return DoActionSetSubsumptionParameter.Value; }
+      set { DoActionSetSubsumptionParameter.Value = value; }
+    }
+    private RandomCreator RandomCreator {
+      get { return (RandomCreator)OperatorGraph.InitialOperator; }
+    }
+    public LearningClassifierSystemMainLoop MainLoop {
+      get { return (LearningClassifierSystemMainLoop)RandomCreator.Successor; }
+    }
     #endregion
 
@@ -98,18 +193,25 @@
       Parameters.Add(new ValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
       Parameters.Add(new ValueParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
-      Parameters.Add(new ValueParameter<IntValue>("PopulationSize", "The size of the population of solutions.", new IntValue(100)));
-      //for test purpose
-      Parameters.Add(new ValueParameter<ICombinedIntegerVectorCreator>("SolutionCreator", "The operator to create a solution.", new UniformRandomCombinedIntegerVectorCreator()));
-      Parameters.Add(new ValueParameter<IntValue>("Length", "The operator to create a solution.", new IntValue(3)));
-      Parameters.Add(new ValueParameter<IntValue>("ActionPartLength", "The operator to create a solution.", new IntValue(1)));
-      int[,] elements = new int[,] { { 0, 3 }, { 0, 3 }, { 0, 2 } };
-      Parameters.Add(new ValueParameter<IntMatrix>("Bounds", "The operator to create a solution.", new IntMatrix(elements)));
+      Parameters.Add(new ValueParameter<BoolValue>("CreateInitialPopulation", "Specifies if a population should be created at the beginning of the algorithm.", new BoolValue(false)));
+      Parameters.Add(new ValueParameter<IntValue>("N", "Max size of the population of solutions.", new IntValue(100)));
+      Parameters.Add(new ValueParameter<PercentValue>("Beta", "Learning rate", new PercentValue(0.1)));
+      Parameters.Add(new ValueParameter<PercentValue>("Alpha", "", new PercentValue(0.1)));
+      Parameters.Add(new ValueParameter<DoubleValue>("ErrorZero", "The error below which classifiers are considered to have equal accuracy", new DoubleValue(10)));
+      Parameters.Add(new ValueParameter<DoubleValue>("v", "Power parameter", new DoubleValue(5)));
+      Parameters.Add(new ValueParameter<PercentValue>("Gamma", "Discount factor", new PercentValue(0.71)));
+      Parameters.Add(new ValueParameter<PercentValue>("CrossoverProbability", "Probability of crossover", new PercentValue(0.9)));
+      Parameters.Add(new ValueParameter<PercentValue>("MutationProbability", "Probability of mutation", new PercentValue(0.05)));
+      Parameters.Add(new ValueParameter<IntValue>("ThetaGA", "GA threshold. GA is applied in a set when the average time since the last GA is greater than ThetaGA.", new IntValue(25)));
+      Parameters.Add(new ValueParameter<IntValue>("ThetaDeletion", "Deletion threshold. If the experience of a classifier is greater than ThetaDeletion, its fitness may be considered in its probability of deletion.", new IntValue(20)));
+      Parameters.Add(new ValueParameter<IntValue>("ThetaSubsumption", "Subsumption threshold. The experience of a classifier must be greater than TheatSubsumption to be able to subsume another classifier.", new IntValue(20)));
+      Parameters.Add(new ValueParameter<PercentValue>("Delta", "Delta specifies the fraction of mean fitness in [P] below which the fitness of a classifier may be considered in its probability of deletion", new PercentValue(0.1)));
+      Parameters.Add(new ValueParameter<PercentValue>("ExplorationProbability", "Probability of selecting the action uniform randomly", new PercentValue(0.5)));
+      Parameters.Add(new ValueParameter<BoolValue>("DoGASubsumption", "Specifies if offsprings are tested for possible logical subsumption by parents.", new BoolValue(true)));
+      Parameters.Add(new ValueParameter<BoolValue>("DoActionSetSubsumption", "Specifies if action set is tested for subsuming classifiers.", new BoolValue(true)));
       #endregion
 
       #region Create operators
       RandomCreator randomCreator = new RandomCreator();
-      SolutionsCreator solutionsCreator = new SolutionsCreator();
-      UniformSubScopesProcessor uniformSubScopeProcessor = new UniformSubScopesProcessor();
-      UniformRandomizer uniformRandomizer = new UniformRandomizer();
+
       //ResultsCollector resultsCollector = new ResultsCollector();
       LearningClassifierSystemMainLoop mainLoop = new LearningClassifierSystemMainLoop();
@@ -120,30 +222,12 @@
       randomCreator.SetSeedRandomlyParameter.ActualName = SetSeedRandomlyParameter.Name;
       randomCreator.SetSeedRandomlyParameter.Value = null;
-
-      SolutionCreatorParameter.Value.ActionPartLengthParameter.ActualName = ActionPartLength.Name;
-      SolutionCreatorParameter.Value.LengthParameter.ActualName = Length.Name;
-      SolutionCreatorParameter.Value.BoundsParameter.ActualName = Bounds.Name;
-
-      solutionsCreator.NumberOfSolutionsParameter.ActualName = PopulationSizeParameter.Name;
-      solutionsCreator.SolutionCreatorParameter.ActualName = SolutionCreatorParameter.Name;
-
-      uniformSubScopeProcessor.Parallel = new BoolValue(true);
-
-      uniformRandomizer.RandomParameter.ActualName = randomCreator.RandomParameter.ActualName;
-      uniformRandomizer.MinParameter.Value = new DoubleValue(0);
-      uniformRandomizer.MaxParameter.Value = new DoubleValue(100);
-      uniformRandomizer.ValueParameter.ActualName = "Fitness";
-
       #endregion
 
       #region Create operator graph
       OperatorGraph.InitialOperator = randomCreator;
-      randomCreator.Successor = solutionsCreator;
-      solutionsCreator.Successor = uniformSubScopeProcessor;
-      uniformSubScopeProcessor.Operator = uniformRandomizer;
-      uniformSubScopeProcessor.Successor = mainLoop;
+      randomCreator.Successor = mainLoop;
       #endregion
     }
-    protected LearningClassifierSystem(LearningClassifierSystem original, Cloner cloner)
+    private LearningClassifierSystem(LearningClassifierSystem original, Cloner cloner)
       : base(original, cloner) {
     }
@@ -153,4 +237,29 @@
     [StorableConstructor]
     private LearningClassifierSystem(bool deserializing) : base(deserializing) { }
+
+    protected override void OnProblemChanged() {
+      if (Problem != null) {
+        ParameterizeEvaluator(Problem.Evaluator);
+        MainLoop.SetCurrentProblem(Problem);
+      }
+      base.OnProblemChanged();
+    }
+    protected override void Problem_EvaluatorChanged(object sender, EventArgs e) {
+      ParameterizeEvaluator(Problem.Evaluator);
+      MainLoop.SetCurrentProblem(Problem);
+      base.Problem_EvaluatorChanged(sender, e);
+    }
+    protected override void Problem_SolutionCreatorChanged(object sender, EventArgs e) {
+      MainLoop.SetCurrentProblem(Problem);
+      base.Problem_SolutionCreatorChanged(sender, e);
+    }
+
+    private void ParameterizeEvaluator(IXCSEvaluator evaluator) {
+      evaluator.ActualTimeParameter.ActualName = "Iteration";
+      evaluator.BetaParameter.ActualName = BetaParameter.Name;
+      evaluator.AlphaParameter.ActualName = AlphaParameter.Name;
+      evaluator.PowerParameter.ActualName = PowerParameter.Name;
+      evaluator.ErrorZeroParameter.ActualName = ErrorZeroParameter.Name;
+    }
   }
 }
Index: branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystemMainLoop.cs
===================================================================
--- branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystemMainLoop.cs	(revision 8941)
+++ branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystemMainLoop.cs	(revision 9089)
@@ -20,9 +20,8 @@
 #endregion
 
-using HeuristicLab.Algorithms.GeneticAlgorithm;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Encodings.CombinedIntegerVectorEncoding;
+using HeuristicLab.Encodings.ConditionActionEncoding;
 using HeuristicLab.Encodings.IntegerVectorEncoding;
 using HeuristicLab.Operators;
@@ -31,5 +30,4 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Random;
 using HeuristicLab.Selection;
 
@@ -40,5 +38,5 @@
   [Item("LearningClassifierSystemMainLoop", "An operator which represents the main loop of a learning classifier system.")]
   [StorableClass]
-  public class LearningClassifierSystemMainLoop : AlgorithmOperator {
+  public sealed class LearningClassifierSystemMainLoop : AlgorithmOperator {
 
     #region Parameter Properties
@@ -54,22 +52,19 @@
     #endregion
 
-    #region Properties
-    public ISelector Selector {
-      get { return SelectorParameter.Value; }
-      set { SelectorParameter.Value = value; }
-    }
-    public ICrossover Crossover {
-      get { return CrossoverParameter.Value; }
-      set { CrossoverParameter.Value = value; }
-    }
-    public IManipulator Mutator {
-      get { return MutatorParameter.Value; }
-      set { MutatorParameter.Value = value; }
-    }
+    #region private properties
+    private SolutionsCreator initialSolutionsCreator;
+    private SolutionsCreator coveringMechanism;
+    private MatchConditionOperator matchConditionOperator;
+    private PredictionArrayCalculator predictionArrayCalculator;
+    private ActionSelector actionSelector;
+
+    private Placeholder evaluator;
+    private Placeholder actionExecuter;
+    private Placeholder classifierFetcher;
     #endregion
 
     [StorableConstructor]
     private LearningClassifierSystemMainLoop(bool deserializing) : base(deserializing) { }
-    protected LearningClassifierSystemMainLoop(LearningClassifierSystemMainLoop original, Cloner cloner)
+    private LearningClassifierSystemMainLoop(LearningClassifierSystemMainLoop original, Cloner cloner)
       : base(original, cloner) {
     }
@@ -85,107 +80,162 @@
       #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 SinglePointCrossover() }, new SinglePointCrossover()));
-      Parameters.Add(new OptionalConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions.", new ItemSet<IManipulator>() { new UniformOnePositionManipulator() }, new UniformOnePositionManipulator()));
-      //for test purposes
-      int[] numbers = new int[3] { 1, 1, 1 };
-      int[,] elements = new int[,] { { 0, 3 }, { 0, 3 }, { 0, 2 } };
-      Parameters.Add(new ValueLookupParameter<CombinedIntegerVector>("TestTarget", "Target for test", new CombinedIntegerVector(numbers, 1, elements)));
-
+      Parameters.Add(new ConstrainedValueParameter<ICrossover>("Crossover", "The operator used to cross solutions.", new ItemSet<ICrossover>() { new HeuristicLab.Encodings.CombinedIntegerVectorEncoding.SinglePointCrossover() }, new HeuristicLab.Encodings.CombinedIntegerVectorEncoding.SinglePointCrossover()));
+      Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator used to evaluate solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
+      UniformOnePositionManipulator test = new UniformOnePositionManipulator();
+      test.IntegerVectorParameter.ActualName = "CombinedIntegerVector";
+      Parameters.Add(new OptionalConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions.", new ItemSet<IManipulator>() { new UniformOnePositionManipulator() }, test));
       #endregion
 
       #region Create operators
       VariableCreator variableCreator = new VariableCreator();
-      MatchSelector conditionMatchSelector = new MatchSelector();
-      MatchSelector actionMatchSelector = new MatchSelector();
+      ConditionalBranch initialPopulationConditionalBranch = new ConditionalBranch();
+      initialSolutionsCreator = new SolutionsCreator();
+      IntCounter iterationCounter = new IntCounter();
+      UniformSubScopesProcessor matchCondtionSubScopesProcessor = new UniformSubScopesProcessor();
+      matchConditionOperator = new MatchConditionOperator();
+      predictionArrayCalculator = new PredictionArrayCalculator();
+      actionSelector = new ActionSelector();
+      UniformSubScopesProcessor matchActionSubScopesProcessor = new UniformSubScopesProcessor();
+      MatchActionOperator matchActionOperator = new MatchActionOperator();
+      ConditionalSelector conditionMatchSelector = new ConditionalSelector();
+      ConditionalSelector actionMatchSelector = new ConditionalSelector();
       SubScopesProcessor coveringSubScopesProcessor = new SubScopesProcessor();
-      SubScopesRemover subScopesRemover = new SubScopesRemover();
+      SubScopesCounter matchsetCounter = new SubScopesCounter();
       Comparator comparator = new Comparator();
-      ConditionalBranch conditionalBranch = new ConditionalBranch();
+      ConditionalBranch coveringConditionalBranch = new ConditionalBranch();
       MergingReducer mergingReducer = new MergingReducer();
-      SolutionsCreator coveringMechanism = new SolutionsCreator();
-      SubScopesProcessor actionSelectionSubScopesProcessor = new SubScopesProcessor();
-      MaxValueActionSelector maxValueActionSelection = new MaxValueActionSelector();
-      GeneticAlgorithmMainLoop geneticAlgorithmMainLoop = new GeneticAlgorithmMainLoop();
-
-      UniformSubScopesProcessor uniformSubScopeProcessor = new UniformSubScopesProcessor();
-      UniformRandomizer uniformRandomizer = new UniformRandomizer();
+      MergingReducer mergingReducerWithSuccessor = new MergingReducer();
+      coveringMechanism = new SolutionsCreator();
+      evaluator = new Placeholder();
+      SubScopesProcessor actionSetSubScopesProcessor = new SubScopesProcessor();
+      DataReducer actionSetSizeDataReducer = new DataReducer();
+      UniformSubScopesProcessor accuracySubScopesProcessor = new UniformSubScopesProcessor();
+      CalculateAccuracy calculateAccuracy = new CalculateAccuracy();
+      SumAccuracy sumAccuracy = new SumAccuracy();
+      UniformSubScopesProcessor updateParametersSubScopesProcessor = new UniformSubScopesProcessor();
+      LCSAdaptedGeneticAlgorithm adaptedGeneticAlgorithmMainLoop = new LCSAdaptedGeneticAlgorithm();
+
+      classifierFetcher = new Placeholder();
+      actionExecuter = new Placeholder();
 
       variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("ZeroIntValue", new IntValue(0)));
       variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("OneIntValue", new IntValue(1)));
+      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Iteration", new IntValue(0)));
+
+      initialPopulationConditionalBranch.ConditionParameter.ActualName = "CreateInitialPopulation";
+
+      initialSolutionsCreator.NumberOfSolutionsParameter.ActualName = "N";
+
+      iterationCounter.ValueParameter.ActualName = "Iteration";
+      iterationCounter.IncrementParameter.ActualName = "OneIntValue";
+
+      matchCondtionSubScopesProcessor.Operator = matchConditionOperator;
+
+      matchConditionOperator.MatchParameter.ActualName = "CombinedIntegerVector";
 
       conditionMatchSelector.CopySelected = new BoolValue(false);
-      conditionMatchSelector.MatchCondition = new BoolValue(true);
-      //this has to be set differently
-      conditionMatchSelector.MatchParameter.ActualName = "CombinedIntegerVector";
-      conditionMatchSelector.TargetMatchParameter.ActualName = "TestTarget";
+      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 = conditionMatchSelector.NumberOfSelectedSubScopesParameter.ActualName;
+      comparator.LeftSideParameter.ActualName = matchsetCounter.ValueParameter.ActualName;
       comparator.ResultParameter.ActualName = "Covering";
       //more than zero solutions have to be selected
       comparator.RightSideParameter.ActualName = "ZeroIntValue";
 
-      conditionalBranch.ConditionParameter.ActualName = "Covering";
-
-      subScopesRemover.SubScopeIndexParameter.ActualName = "OneIntValue";
-      subScopesRemover.RemoveAllSubScopes = false;
+      coveringConditionalBranch.Name = "Covering Branch";
+      coveringConditionalBranch.ConditionParameter.ActualName = "Covering";
+
+      matchActionSubScopesProcessor.Operator = matchActionOperator;
+
+      matchActionOperator.MatchParameter.ActualName = "CombinedIntegerVector";
+      matchActionOperator.TargetMatchParameter.ActualName = actionSelector.SelectedActionParameter.ActualName;
 
       coveringMechanism.NumberOfSolutionsParameter.ActualName = "OneIntValue";
-      coveringMechanism.SolutionCreatorParameter.ActualName = "SolutionCreator";
-
-      maxValueActionSelection.ValueParameter.ActualName = "Fitness";
-      maxValueActionSelection.MatchParameter.ActualName = "CombinedIntegerVector";
+
+      predictionArrayCalculator.MatchParameter.ActualName = "CombinedIntegerVector";
+
+      actionSelector.PredictionArrayParameter.ActualName = predictionArrayCalculator.PredictionArrayParameter.Name;
+      actionSelector.RandomParameter.ActualName = "Random";
+      actionSelector.ExplorationProbabilityParameter.ActualName = "ExplorationProbability";
 
       actionMatchSelector.CopySelected = new BoolValue(false);
-      actionMatchSelector.MatchCondition = new BoolValue(false);
-      //this has to be set differently
-      actionMatchSelector.MatchParameter.ActualName = "CombinedIntegerVector";
-      actionMatchSelector.TargetMatchParameter.ActualName = maxValueActionSelection.SelectedActionParameter.ActualName;
+      actionMatchSelector.ConditionParameter.ActualName = "MatchAction";
 
       SelectorParameter.Value.CopySelected = new BoolValue(true);
       SelectorParameter.Value.NumberOfSelectedSubScopesParameter.Value = new IntValue(200);
 
-      geneticAlgorithmMainLoop.SelectorParameter.ActualName = SelectorParameter.Name;
-      geneticAlgorithmMainLoop.CrossoverParameter.ActualName = CrossoverParameter.Name;
-      geneticAlgorithmMainLoop.MutatorParameter.ActualName = MutatorParameter.Name;
-      geneticAlgorithmMainLoop.RandomParameter.ActualName = "Random";
-      geneticAlgorithmMainLoop.ElitesParameter.ActualName = "OneIntValue";
-      geneticAlgorithmMainLoop.MaximumGenerationsParameter.ActualName = "ZeroIntValue";
-      geneticAlgorithmMainLoop.QualityParameter.ActualName = "Fitness";
+      evaluator.Name = "Evaluator";
+
+      classifierFetcher.Name = "ClassifierFetcher";
+
+      actionExecuter.Name = "ActionExecuter";
+
+      actionSetSizeDataReducer.TargetParameter.ActualName = "CurrentActionSetSize";
+      actionSetSizeDataReducer.ParameterToReduce.ActualName = "Numerosity";
+      actionSetSizeDataReducer.ReductionOperation.Value = new ReductionOperation(ReductionOperations.Sum);
+      actionSetSizeDataReducer.TargetOperation.Value = new ReductionOperation(ReductionOperations.Assign);
+
+      calculateAccuracy.AlphaParameter.ActualName = "Alpha";
+      calculateAccuracy.ErrorParameter.ActualName = "Error";
+      calculateAccuracy.ErrorZeroParameter.ActualName = "ErrorZero";
+      calculateAccuracy.PowerParameter.ActualName = "v";
+
+      sumAccuracy.AccuracyParameter.ActualName = calculateAccuracy.AccuracyParameter.ActualName;
+      sumAccuracy.NumerosityParameter.ActualName = "Numerosity";
+
+      adaptedGeneticAlgorithmMainLoop.SelectorParameter.ActualName = SelectorParameter.Name;
+      adaptedGeneticAlgorithmMainLoop.CrossoverParameter.ActualName = CrossoverParameter.Name;
+      adaptedGeneticAlgorithmMainLoop.MutatorParameter.ActualName = MutatorParameter.Name;
+      adaptedGeneticAlgorithmMainLoop.RandomParameter.ActualName = "Random";
+      adaptedGeneticAlgorithmMainLoop.MaximumGenerationsParameter.ActualName = "ZeroIntValue";
+      adaptedGeneticAlgorithmMainLoop.QualityParameter.ActualName = "Fitness";
       //needed?
-      geneticAlgorithmMainLoop.MutationProbabilityParameter.Value = new PercentValue(10);
-      geneticAlgorithmMainLoop.MaximizationParameter.Value = new BoolValue(true);
-
-      uniformSubScopeProcessor.Parallel = new BoolValue(true);
-
-      uniformRandomizer.RandomParameter.ActualName = "Random";
-      uniformRandomizer.MinParameter.Value = new DoubleValue(0);
-      uniformRandomizer.MaxParameter.Value = new DoubleValue(100);
-      uniformRandomizer.ValueParameter.ActualName = "Fitness";
-
-      //ParameterizeSelectors();
+      adaptedGeneticAlgorithmMainLoop.MutationProbabilityParameter.Value = new PercentValue(10);
+      adaptedGeneticAlgorithmMainLoop.MaximizationParameter.Value = new BoolValue(true);
       #endregion
 
       #region Create operator graph
       OperatorGraph.InitialOperator = variableCreator;
-      variableCreator.Successor = conditionMatchSelector;
-      //variableCreator.Successor = geneticAlgorithmMainLoop;
-      //geneticAlgorithmMainLoop.Successor = conditionMatchSelector;
-      conditionMatchSelector.Successor = comparator;
-      comparator.Successor = conditionalBranch;
-      conditionalBranch.TrueBranch = coveringSubScopesProcessor;
-      conditionalBranch.FalseBranch = actionSelectionSubScopesProcessor;
-      conditionalBranch.Successor = subScopesRemover;
-      coveringMechanism.Successor = uniformSubScopeProcessor;
-      uniformSubScopeProcessor.Operator = uniformRandomizer;
+
+      variableCreator.Successor = initialPopulationConditionalBranch;
+      initialPopulationConditionalBranch.TrueBranch = initialSolutionsCreator;
+      initialPopulationConditionalBranch.FalseBranch = new EmptyOperator();
+      initialPopulationConditionalBranch.Successor = classifierFetcher;
+      classifierFetcher.Successor = matchCondtionSubScopesProcessor;
+      matchCondtionSubScopesProcessor.Successor = conditionMatchSelector;
+      //variableCreator.Successor = adaptedGeneticAlgorithmMainLoop;
+      //adaptedGeneticAlgorithmMainLoop.Successor = conditionMatchSelector;
+
+      conditionMatchSelector.Successor = coveringSubScopesProcessor;
       coveringSubScopesProcessor.Operators.Add(new EmptyOperator());
-      coveringSubScopesProcessor.Operators.Add(coveringMechanism);
-      coveringSubScopesProcessor.Successor = actionSelectionSubScopesProcessor;
-      actionSelectionSubScopesProcessor.Operators.Add(new EmptyOperator());
-      actionSelectionSubScopesProcessor.Operators.Add(maxValueActionSelection);
-      maxValueActionSelection.Successor = actionMatchSelector;
-      subScopesRemover.Successor = mergingReducer;
-      mergingReducer.Successor = conditionMatchSelector;
-      //mergingReducer.Successor = geneticAlgorithmMainLoop;
+      coveringSubScopesProcessor.Operators.Add(matchsetCounter);
+      coveringSubScopesProcessor.Successor = mergingReducerWithSuccessor;
+      matchsetCounter.Successor = comparator;
+      comparator.Successor = coveringConditionalBranch;
+      coveringConditionalBranch.TrueBranch = coveringMechanism;
+      coveringConditionalBranch.FalseBranch = new EmptyOperator();
+      coveringConditionalBranch.Successor = predictionArrayCalculator;
+      predictionArrayCalculator.Successor = actionSelector;
+      actionSelector.Successor = matchActionSubScopesProcessor;
+      matchActionSubScopesProcessor.Successor = actionMatchSelector;
+      actionMatchSelector.Successor = actionExecuter;
+      actionExecuter.Successor = actionSetSubScopesProcessor;
+      actionSetSubScopesProcessor.Operators.Add(new EmptyOperator());
+      actionSetSubScopesProcessor.Operators.Add(actionSetSizeDataReducer);
+      actionSetSizeDataReducer.Successor = accuracySubScopesProcessor;
+      accuracySubScopesProcessor.Operator = calculateAccuracy;
+      accuracySubScopesProcessor.Successor = sumAccuracy;
+      sumAccuracy.Successor = updateParametersSubScopesProcessor;
+      updateParametersSubScopesProcessor.Operator = evaluator;
+
+      actionSetSubScopesProcessor.Successor = mergingReducer;
+
+      mergingReducerWithSuccessor.Successor = iterationCounter;
+      iterationCounter.Successor = classifierFetcher;
+      //mergingReducer.Successor = adaptedGeneticAlgorithmMainLoop;
       #endregion
     }
@@ -197,4 +247,27 @@
         stochasticOp.RandomParameter.Hidden = true;
       }
+    }
+
+    internal void SetCurrentProblem(IConditionActionProblem problem) {
+      initialSolutionsCreator.SolutionCreatorParameter.ActualName = problem.SolutionCreatorParameter.Name;
+      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;
+
+      problem.ClassifierFetcher.IterationParameter.ActualName = "Iteration";
+
+      evaluator.OperatorParameter.ActualName = problem.EvaluatorParameter.Name;
+
+      classifierFetcher.OperatorParameter.ActualName = problem.ClassifierFetcherParameter.Name;
+
+      actionExecuter.OperatorParameter.ActualName = problem.ActionExecuterParameter.Name;
+
+      matchConditionOperator.TargetMatchParameter.ActualName = problem.ClassifierFetcher.CurrentClassifierToMatchParameter.Name;
+
+      predictionArrayCalculator.PredictionParameter.ActualName = problem.Evaluator.PredictionParameter.ActualName;
+      predictionArrayCalculator.FitnessParameter.ActualName = problem.Evaluator.FitnessParameter.ActualName;
     }
     //private void ParameterizeSelectors() {
