Index: branches/ProblemRefactoring/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/EvaluationTracker.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/EvaluationTracker.cs	(revision 13339)
+++ branches/ProblemRefactoring/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/EvaluationTracker.cs	(revision 13361)
@@ -22,11 +22,8 @@
 
 using System;
-using HeuristicLab.Common;
+using System.Collections.Generic;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 using HeuristicLab.Encodings.BinaryVectorEncoding;
 using HeuristicLab.Optimization;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Algorithms.ParameterlessPopulationPyramid {
@@ -34,6 +31,6 @@
   // B. W. Goldman and W. F. Punch, "Parameter-less Population Pyramid," GECCO, pp. 785–792, 2014
   // and the original source code in C++11 available from: https://github.com/brianwgoldman/Parameter-less_Population_Pyramid
-  internal sealed class EvaluationTracker : SingleObjectiveProblem<BinaryVectorEncoding, BinaryVector> {
-    private readonly ISingleObjectiveProblem<BinaryVectorEncoding, BinaryVector> problem;
+  internal sealed class EvaluationTracker : ISingleObjectiveProblemDefinition<BinaryVectorEncoding, BinaryVector> {
+    private readonly ISingleObjectiveProblemDefinition<BinaryVectorEncoding, BinaryVector> problem;
 
     private int maxEvaluations;
@@ -60,24 +57,10 @@
     }
 
-    public new BinaryVectorEncoding Encoding {
+    public BinaryVectorEncoding Encoding {
       get { return problem.Encoding; }
     }
     #endregion
 
-    [StorableConstructor]
-    private EvaluationTracker(bool deserializing) : base(deserializing) { }
-    private EvaluationTracker(EvaluationTracker original, Cloner cloner)
-      : base(original, cloner) {
-      problem = cloner.Clone(original.problem);
-      maxEvaluations = original.maxEvaluations;
-      BestQuality = original.BestQuality;
-      Evaluations = original.Evaluations;
-      BestFoundOnEvaluation = original.BestFoundOnEvaluation;
-      BestSolution = cloner.Clone(BestSolution);
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new EvaluationTracker(this, cloner);
-    }
-    public EvaluationTracker(ISingleObjectiveProblem<BinaryVectorEncoding, BinaryVector> problem, int maxEvaluations) {
+    public EvaluationTracker(ISingleObjectiveProblemDefinition<BinaryVectorEncoding, BinaryVector> problem, int maxEvaluations) {
       this.problem = problem;
       this.maxEvaluations = maxEvaluations;
@@ -86,10 +69,9 @@
       Evaluations = 0;
       BestFoundOnEvaluation = 0;
-
-      if (Parameters.ContainsKey("Maximization")) Parameters.Remove("Maximization");
-      Parameters.Add(new FixedValueParameter<BoolValue>("Maximization", "Set to false if the problem should be minimized.", (BoolValue)new BoolValue(Maximization).AsReadOnly()) { Hidden = true });
     }
 
-    public override double Evaluate(BinaryVector vector, IRandom random) {
+
+
+    public double Evaluate(BinaryVector vector, IRandom random) {
       if (Evaluations >= maxEvaluations) throw new OperationCanceledException("Maximum Evaluation Limit Reached");
       Evaluations++;
@@ -103,5 +85,5 @@
     }
 
-    public override bool Maximization {
+    public bool Maximization {
       get {
         if (problem == null) return false;
@@ -110,8 +92,15 @@
     }
 
-    public override bool IsBetter(double quality, double bestQuality) {
+    public bool IsBetter(double quality, double bestQuality) {
       return problem.IsBetter(quality, bestQuality);
     }
 
+    public void Analyze(BinaryVector[] individuals, double[] qualities, ResultCollection results, IRandom random) {
+      problem.Analyze(individuals, qualities, results, random);
+    }
+
+    public IEnumerable<BinaryVector> GetNeighbors(BinaryVector individual, IRandom random) {
+      return problem.GetNeighbors(individual, random);
+    }
   }
 }
Index: branches/ProblemRefactoring/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/HillClimber.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/HillClimber.cs	(revision 13339)
+++ branches/ProblemRefactoring/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/HillClimber.cs	(revision 13361)
@@ -49,9 +49,9 @@
 
     public override Type ProblemType {
-      get { return typeof(ISingleObjectiveProblem<BinaryVectorEncoding, BinaryVector>); }
+      get { return typeof(ISingleObjectiveProblemDefinition<BinaryVectorEncoding, BinaryVector>); }
     }
-    public new ISingleObjectiveProblem<BinaryVectorEncoding, BinaryVector> Problem {
-      get { return (ISingleObjectiveProblem<BinaryVectorEncoding, BinaryVector>)base.Problem; }
-      set { base.Problem = value; }
+    public new ISingleObjectiveProblemDefinition<BinaryVectorEncoding, BinaryVector> Problem {
+      get { return (ISingleObjectiveProblemDefinition<BinaryVectorEncoding, BinaryVector>)base.Problem; }
+      set { base.Problem = (IProblem)value; }
     }
 
@@ -97,5 +97,5 @@
     }
     // In the GECCO paper, Section 2.1
-    public static double ImproveToLocalOptimum(ISingleObjectiveProblem<BinaryVectorEncoding, BinaryVector> problem, BinaryVector solution, double fitness, IRandom rand) {
+    public static double ImproveToLocalOptimum(ISingleObjectiveProblemDefinition<BinaryVectorEncoding, BinaryVector> problem, BinaryVector solution, double fitness, IRandom rand) {
       var tried = new HashSet<int>();
       do {
Index: branches/ProblemRefactoring/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/LinkageCrossover.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/LinkageCrossover.cs	(revision 13339)
+++ branches/ProblemRefactoring/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/LinkageCrossover.cs	(revision 13361)
@@ -33,5 +33,5 @@
   public static class LinkageCrossover {
     // In the GECCO paper, Figure 3
-    public static double ImproveUsingTree(LinkageTree tree, IList<BinaryVector> donors, BinaryVector solution, double fitness, ISingleObjectiveProblem<BinaryVectorEncoding, BinaryVector> problem, IRandom rand) {
+    public static double ImproveUsingTree(LinkageTree tree, IList<BinaryVector> donors, BinaryVector solution, double fitness, ISingleObjectiveProblemDefinition<BinaryVectorEncoding, BinaryVector> problem, IRandom rand) {
       var options = Enumerable.Range(0, donors.Count).ToArray();
       foreach (var cluster in tree.Clusters) {
@@ -48,5 +48,5 @@
     }
 
-    private static double Donate(BinaryVector solution, double fitness, BinaryVector source, IEnumerable<int> cluster, ISingleObjectiveProblem<BinaryVectorEncoding, BinaryVector> problem, IRandom rand, out bool changed) {
+    private static double Donate(BinaryVector solution, double fitness, BinaryVector source, IEnumerable<int> cluster, ISingleObjectiveProblemDefinition<BinaryVectorEncoding, BinaryVector> problem, IRandom rand, out bool changed) {
       // keep track of which bits flipped to make the donation
       List<int> flipped = new List<int>();
Index: branches/ProblemRefactoring/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/ParameterlessPopulationPyramid.cs
===================================================================
--- branches/ProblemRefactoring/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/ParameterlessPopulationPyramid.cs	(revision 13339)
+++ branches/ProblemRefactoring/HeuristicLab.Algorithms.ParameterlessPopulationPyramid/3.3/ParameterlessPopulationPyramid.cs	(revision 13361)
@@ -45,7 +45,7 @@
       get { return typeof(ISingleObjectiveProblem<BinaryVectorEncoding, BinaryVector>); }
     }
-    public new ISingleObjectiveProblem<BinaryVectorEncoding, BinaryVector> Problem {
-      get { return (ISingleObjectiveProblem<BinaryVectorEncoding, BinaryVector>)base.Problem; }
-      set { base.Problem = value; }
+    public new ISingleObjectiveProblemDefinition<BinaryVectorEncoding, BinaryVector> Problem {
+      get { return (ISingleObjectiveProblemDefinition<BinaryVectorEncoding, BinaryVector>)base.Problem; }
+      set { base.Problem = (IProblem)value; }
     }
 
@@ -182,5 +182,5 @@
       if (seen.Contains(solution)) return;
       if (level == pyramid.Count) {
-        pyramid.Add(new Population(tracker.Encoding.Length, random));
+        pyramid.Add(new Population(Problem.Encoding.Length, random));
       }
       var copied = (BinaryVector)solution.Clone();
@@ -192,5 +192,5 @@
     private double iterate() {
       // Create a random solution
-      BinaryVector solution = new BinaryVector(tracker.Encoding.Length);
+      BinaryVector solution = new BinaryVector(Problem.Encoding.Length);
       for (int i = 0; i < solution.Length; i++) {
         solution[i] = random.Next(2) == 1;
