Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/IIndividualZeroErrorAnalyzer.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/IIndividualZeroErrorAnalyzer.cs	(revision 15273)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/IIndividualZeroErrorAnalyzer.cs	(revision 15273)
@@ -0,0 +1,7 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Analyzer {
+  using HeuristicLab.Optimization;
+
+  public interface IIndividualZeroErrorAnalyzer : IAnalyzer {
+
+  }
+}
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/IndividualZeroErrorAnalyzer.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/IndividualZeroErrorAnalyzer.cs	(revision 15273)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/IndividualZeroErrorAnalyzer.cs	(revision 15273)
@@ -0,0 +1,135 @@
+﻿namespace HeuristicLab.Problems.ProgramSynthesis.Push.Analyzer {
+
+  using HeuristicLab.Analysis;
+  using HeuristicLab.Common;
+  using HeuristicLab.Core;
+  using HeuristicLab.Data;
+  using HeuristicLab.Operators;
+  using HeuristicLab.Optimization;
+  using HeuristicLab.Parameters;
+  using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Problem;
+
+  /// <summary>
+  /// An operater that tracks the count of individuals with zero error on the cases
+  /// </summary>
+  [Item("IndividualZeroErrorAnalyzer", "An operater that tracks the count of individuals with zero error on the cases")]
+  [StorableClass]
+  public class IndividualZeroErrorAnalyzer : SingleSuccessorOperator, IIndividualZeroErrorAnalyzer {
+    private const string RESULTS_PARAMETER_NAME = "Results";
+    private const string INDIVIDUAL_ZERO_ERROR_PARAMETER_NAME = "ZeroErrorIndividualsPerCase";
+
+    private const string RESULT_PARAMETER_NAME = "Zero Error Individuals Per Case";
+    private const string RESULT_PARAMETER_DESCRIPTION = "Relative frequency of instructions aggregated over the whole population.";
+    private const string Y_AXIS_TITLE = "Count if zero error individuals";
+    private const string X_AXIS_TITLE = "Case Index";
+    private const string ROW_NAME = "Cases";
+
+    public IndividualZeroErrorAnalyzer() {
+      Parameters.Add(new LookupParameter<DataTable>(
+        INDIVIDUAL_ZERO_ERROR_PARAMETER_NAME,
+        "The data table to store the count of individuals with zero error."));
+
+      Parameters.Add(new LookupParameter<ResultCollection>(
+        RESULTS_PARAMETER_NAME,
+        "The result collection where the symbol frequencies should be stored."));
+
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleArray>(
+       PushProblem.CaseQualitiesScopeParameterName,
+       "The quality of every single training case for each individual."));
+    }
+
+    [StorableConstructor]
+    public IndividualZeroErrorAnalyzer(bool deserializing) : base(deserializing) { }
+
+    public IndividualZeroErrorAnalyzer(IndividualZeroErrorAnalyzer origin, Cloner cloner) : base(origin, cloner) { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new IndividualZeroErrorAnalyzer(this, cloner);
+    }
+
+    public bool EnabledByDefault { get { return true; } }
+
+    public ILookupParameter<DataTable> IndividualZeroErrorParameter
+    {
+      get { return (ILookupParameter<DataTable>)Parameters[INDIVIDUAL_ZERO_ERROR_PARAMETER_NAME]; }
+    }
+
+    public ILookupParameter<ResultCollection> ResultsParameter
+    {
+      get { return (ILookupParameter<ResultCollection>)Parameters[RESULTS_PARAMETER_NAME]; }
+    }
+
+    public ILookupParameter<ItemArray<DoubleArray>> CaseQualitiesParameter
+    {
+      get { return (ILookupParameter<ItemArray<DoubleArray>>)Parameters[PushProblem.CaseQualitiesScopeParameterName]; }
+    }
+
+    public override IOperation Apply() {
+      var caseQualitiesPerIndividual = CaseQualitiesParameter.ActualValue;
+      var caseCount = caseQualitiesPerIndividual[0].Length;
+
+      var results = ResultsParameter.ActualValue;
+      var individualZeroErrorCounts = IndividualZeroErrorParameter.ActualValue;
+
+      if (individualZeroErrorCounts == null) {
+        individualZeroErrorCounts = new DataTable(
+         RESULT_PARAMETER_NAME,
+         RESULT_PARAMETER_DESCRIPTION) {
+          VisualProperties = {
+            YAxisTitle = Y_AXIS_TITLE,
+            XAxisTitle = X_AXIS_TITLE,
+            XAxisMinimumFixedValue = 0,
+            XAxisMaximumFixedValue = caseCount,
+            XAxisMaximumAuto = false,
+            XAxisMinimumAuto = false,
+          }
+        };
+
+        IndividualZeroErrorParameter.ActualValue = individualZeroErrorCounts;
+      }
+
+      if (!results.ContainsKey(RESULT_PARAMETER_NAME)) {
+        results.Add(new Result(RESULT_PARAMETER_NAME, individualZeroErrorCounts));
+      }
+
+      DataRow row;
+      if (!individualZeroErrorCounts.Rows.TryGetValue(ROW_NAME, out row)) {
+        row = new DataRow(ROW_NAME) {
+          VisualProperties = {
+              StartIndexZero = true,
+              IsVisibleInLegend = false,
+              ChartType = DataRowVisualProperties.DataRowChartType.Bars,
+            }
+        };
+
+        individualZeroErrorCounts.Rows.Add(row);
+      }
+
+      var caseCountChanged = row.Values.Count != caseCount;
+
+      if (caseCountChanged) {
+        individualZeroErrorCounts.VisualProperties.XAxisMaximumFixedValue = caseCount;
+        row.Values.Clear();
+      }
+
+      for (var i = 0; i < caseCount; i++) {
+        var count = 0;
+
+        for (var j = 0; j < caseQualitiesPerIndividual.Length; j++) {
+          var caseQuality = caseQualitiesPerIndividual[j][i];
+
+          if (caseQuality == 0.0)
+            count++;
+        }
+
+        if (caseCountChanged)
+          row.Values.Add(count);
+        else
+          row.Values[i] = count;
+      }
+
+      return base.Apply();
+    }
+  }
+}
Index: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/PushExpressionFrequencyAnalyzer.cs
===================================================================
--- branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/PushExpressionFrequencyAnalyzer.cs	(revision 15189)
+++ branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Analyzer/PushExpressionFrequencyAnalyzer.cs	(revision 15273)
@@ -12,7 +12,9 @@
   using HeuristicLab.Parameters;
   using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Attributes;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Individual;
+  using HeuristicLab.Problems.ProgramSynthesis.Push.ObjectPools.Random;
 
   /// <summary>
@@ -22,18 +24,24 @@
   [StorableClass]
   public class PushExpressionFrequencyAnalyzer : SingleSuccessorOperator, IPushExpressionAnalyzer {
+    private readonly SeededRandomPool randomPool = new SeededRandomPool();
 
-    private const string PushConfigurationParameterName = "PushConfiguration";
-    private const string IntegerVectorParameterName = "IntegerVector";
-    private const string ResultsParameterName = "Results";
-    private const string ExpressionFrequenciesParameterName = "InstructionFrequencies";
-    private const string AggregateStackTypesParameterName = "Aggregate stack types";
+    private const string PUSH_CONFIGURATION_PARAMETER_NAME = "PushConfiguration";
+    private const string INTEGER_VECTOR_PARAMETER_NAME = "IntegerVector";
+    private const string RESULTS_PARAMETER_NAME = "Results";
+    private const string EXPRESSION_FREQUENCIES_PARAMETER_NAME = "InstructionFrequencies";
+    private const string AGGREGATE_STACK_TYPES_PARAMETER_NAME = "Aggregate stack types";
+    private const string IN_EXPRESSION_GROUP_NAME = "IN";
+    private const string RANDOM_PARAMETER_NAME = "Random";
+    private const string RESULT_PARAMETER_NAME = "Instruction frequencies";
+    private const string RESULT_PARAMETER_DESCRIPTION = "Relative frequency of instructions aggregated over the whole population.";
+    private const string Y_AXIS_TITLE = "Relative Instruction Frequency";
 
     public PushExpressionFrequencyAnalyzer() {
-      Parameters.Add(new LookupParameter<IReadOnlyPushConfiguration>(PushConfigurationParameterName, "The current specified push configuration."));
-      Parameters.Add(new ScopeTreeLookupParameter<IntegerVector>(IntegerVectorParameterName, "The integer vectors to analyze."));
-      Parameters.Add(new LookupParameter<DataTable>(ExpressionFrequenciesParameterName, "The data table to store the instruction frequencies."));
-      Parameters.Add(new LookupParameter<ResultCollection>(ResultsParameterName, "The result collection where the symbol frequencies should be stored."));
+      Parameters.Add(new LookupParameter<IReadOnlyPushConfiguration>(PUSH_CONFIGURATION_PARAMETER_NAME, "The current specified push configuration."));
+      Parameters.Add(new ScopeTreeLookupParameter<IntegerVector>(INTEGER_VECTOR_PARAMETER_NAME, "The integer vectors to analyze."));
+      Parameters.Add(new LookupParameter<DataTable>(EXPRESSION_FREQUENCIES_PARAMETER_NAME, "The data table to store the instruction frequencies."));
+      Parameters.Add(new LookupParameter<ResultCollection>(RESULTS_PARAMETER_NAME, "The result collection where the symbol frequencies should be stored."));
 
-      Parameters.Add(new FixedValueParameter<BoolValue>(AggregateStackTypesParameterName, "Determines if expressions should be aggregated by their primary stack type.", new BoolValue(true)));
+      Parameters.Add(new FixedValueParameter<BoolValue>(AGGREGATE_STACK_TYPES_PARAMETER_NAME, "Determines if expressions should be aggregated by their primary stack type.", new BoolValue(true)));
     }
 
@@ -51,25 +59,30 @@
     public ILookupParameter<IReadOnlyPushConfiguration> PushConfigurationParameter
     {
-      get { return (ILookupParameter<IReadOnlyPushConfiguration>)Parameters[PushConfigurationParameterName]; }
+      get { return (ILookupParameter<IReadOnlyPushConfiguration>)Parameters[PUSH_CONFIGURATION_PARAMETER_NAME]; }
     }
 
     public IScopeTreeLookupParameter<IntegerVector> IntegerVectorParameter
     {
-      get { return (IScopeTreeLookupParameter<IntegerVector>)Parameters[IntegerVectorParameterName]; }
+      get { return (IScopeTreeLookupParameter<IntegerVector>)Parameters[INTEGER_VECTOR_PARAMETER_NAME]; }
     }
 
     public ILookupParameter<DataTable> ExpressionFrequenciesParameter
     {
-      get { return (ILookupParameter<DataTable>)Parameters[ExpressionFrequenciesParameterName]; }
+      get { return (ILookupParameter<DataTable>)Parameters[EXPRESSION_FREQUENCIES_PARAMETER_NAME]; }
+    }
+
+    public ILookupParameter<IRandom> RandomParameter
+    {
+      get { return (ILookupParameter<IRandom>)Parameters[RANDOM_PARAMETER_NAME]; }
     }
 
     public ILookupParameter<ResultCollection> ResultsParameter
     {
-      get { return (ILookupParameter<ResultCollection>)Parameters[ResultsParameterName]; }
+      get { return (ILookupParameter<ResultCollection>)Parameters[RESULTS_PARAMETER_NAME]; }
     }
 
     public IValueParameter<BoolValue> AggregateStackTypesParameter
     {
-      get { return (IValueParameter<BoolValue>)Parameters[AggregateStackTypesParameterName]; }
+      get { return (IValueParameter<BoolValue>)Parameters[AGGREGATE_STACK_TYPES_PARAMETER_NAME]; }
     }
 
@@ -80,9 +93,17 @@
     }
 
-
     public override IOperation Apply() {
       var config = PushConfigurationParameter.ActualValue;
       var integerVectors = IntegerVectorParameter.ActualValue;
-      var pushPrograms = integerVectors.Select(iv => iv.ToPushProgram(config));
+
+      randomPool.Seed = config.Seed;
+
+      var pushPrograms = integerVectors.Select(iv => {
+        var random = randomPool.ResetAndAllocate();
+        var program = iv.ToPushProgram(config, random);
+        randomPool.Free(random);
+
+        return program;
+      });
 
       var results = ResultsParameter.ActualValue;
@@ -91,13 +112,13 @@
       if (frequencies == null) {
         frequencies = new DataTable(
-          "Instruction frequencies",
-          "Relative frequency of instructions aggregated over the whole population.") {
+          RESULT_PARAMETER_NAME,
+          RESULT_PARAMETER_DESCRIPTION) {
           VisualProperties = {
-            YAxisTitle = "Relative Instruction Frequency"
+            YAxisTitle = Y_AXIS_TITLE
           }
         };
 
         ExpressionFrequenciesParameter.ActualValue = frequencies;
-        results.Add(new Result("Instruction frequencies", frequencies));
+        results.Add(new Result(RESULT_PARAMETER_NAME, frequencies));
       }
 
@@ -110,7 +131,5 @@
 
       var expressionFrequencies = allExpressions
-        .GroupBy(x => AggregateStackTypes
-          ? x.Attribute.StackType.ToString()
-          : x.Attribute.Name)
+        .GroupBy(x => GetGroupName(x.Attribute, AggregateStackTypes))
         .ToDictionary(
           group => group.Key,
@@ -126,5 +145,5 @@
           var row = new DataRow(pair.Key, string.Empty, Enumerable.Repeat(0.0, numberOfValues)) {
             VisualProperties = {
-              StartIndexZero = true
+              StartIndexZero = true,
             }
           };
@@ -142,4 +161,14 @@
       return base.Apply();
     }
+
+    private string GetGroupName(PushExpressionAttribute attribute, bool aggregateStackTypes) {
+      if (aggregateStackTypes) {
+        return attribute.IsInExpression
+         ? IN_EXPRESSION_GROUP_NAME
+         : attribute.StackType.ToString();
+      }
+
+      return attribute.Name;
+    }
   }
 }
