Changeset 5686 for branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests

Timestamp:

03/15/11 13:34:38 (14 years ago)

Author:

mkommend

Message:

#1418: Finally added results from the grammar refactoring.

Location:

branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests

Files:

• AllArchitectureAlteringOperatorsTest.cs (modified) (5 diffs)
• ArgumentCreaterTest.cs (modified) (4 diffs)
• ArgumentDeleterTest.cs (modified) (2 diffs)
• ArgumentDuplicaterTest.cs (modified) (3 diffs)
• ChangeNodeTypeManipulationTest.cs (modified) (1 diff)
• Grammars.cs (modified) (2 diffs)
• ProbabilisticTreeCreaterTest.cs (modified) (3 diffs)
• ReplaceBranchManipulationTest.cs (modified) (1 diff)
• SubroutineCreaterTest.cs (modified) (3 diffs)
• SubroutineDeleterTest.cs (modified) (2 diffs)
• SubroutineDuplicaterTest.cs (modified) (2 diffs)
• SubtreeCrossoverTest.cs (modified) (2 diffs)
• Util.cs (modified) (2 diffs)

branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/AllArchitectureAlteringOperatorsTest.cs

@@ -56 +56 @@
       var grammar = Grammars.CreateArithmeticAndAdfGrammar();
       var random = new MersenneTwister(31415);
+      SymbolicExpressionTreeStringFormatter formatter = new SymbolicExpressionTreeStringFormatter();
       IntValue maxTreeSize = new IntValue(MAX_TREE_LENGTH);
       IntValue maxTreeHeigth = new IntValue(MAX_TREE_DEPTH);
@@ -61 +62 @@
       IntValue maxArgs = new IntValue(3);
       for (int i = 0; i < POPULATION_SIZE; i++) {
-        var tree = ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_LENGTH, MAX_TREE_DEPTH, 3, 3);
+        var tree = ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_LENGTH, MAX_TREE_DEPTH);
         Util.IsValid(tree);
         trees.Add(tree);
       }
       Stopwatch stopwatch = new Stopwatch();
-      stopwatch.Start();
       int failedEvents = 0;
       for (int g = 0; g < N_ITERATIONS; g++) {
@@ -72 +72 @@
           if (random.NextDouble() < 0.5) {
             // manipulate
+            stopwatch.Start();
             var selectedTree = (ISymbolicExpressionTree)trees.SelectRandom(random).Clone();
+            var oldTree = (ISymbolicExpressionTree)selectedTree.Clone();
+            var oldFormatedTree = formatter.Format(oldTree);
             bool success = false;
-            switch (random.Next(6)) {
+            int sw = random.Next(6);
+            switch (sw) {
               case 0: success = ArgumentCreater.CreateNewArgument(random, selectedTree, MAX_TREE_LENGTH, MAX_TREE_DEPTH, 3, 3); break;
               case 1: success = ArgumentDeleter.DeleteArgument(random, selectedTree, 3, 3); break;
@@ -82 +86 @@
               case 5: success = SubroutineDeleter.DeleteSubroutine(random, selectedTree, 3, 3); break;
             }
+            stopwatch.Stop();
             if (!success) failedEvents++;
+            var newFormatedTree = formatter.Format(selectedTree);
             Util.IsValid(selectedTree);
             newTrees.Add(selectedTree);
@@ -98 +104 @@
         trees = newTrees;
       }
-      stopwatch.Stop();
       var msPerOperation = stopwatch.ElapsedMilliseconds / (double)POPULATION_SIZE / (double)N_ITERATIONS;
       Console.WriteLine("AllArchitectureAlteringOperators: " + Environment.NewLine +

branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/ArgumentCreaterTest.cs

@@ -21 +21 @@
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
-using System.Collections.Generic;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Random;
@@ -57 +57 @@
         ISymbolicExpressionTree tree;
         do {
-          tree = ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_LENGTH, MAX_TREE_DEPTH, 3, 3);
+          tree = ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_LENGTH, MAX_TREE_DEPTH);
+          SubroutineCreater.CreateSubroutine(random, tree, MAX_TREE_LENGTH, MAX_TREE_DEPTH, 3, 3);
         } while (!TreeHasAdfWithParameter(tree, 3));
         var success = ArgumentCreater.CreateNewArgument(random, tree, 60000, 100, 3, 3);
@@ -66 +67 @@
       // difficult to make sure that create argument operations succeed because trees are macro-expanded can potentially become very big 
       // => just test if only a small proportion fails
-      Assert.IsTrue(failedOps < POPULATION_SIZE * 0.01 ); // only 1% may fail
+      Assert.IsTrue(failedOps < POPULATION_SIZE * 0.01); // only 1% may fail
       Console.WriteLine("ArgumentCreator: " + Environment.NewLine +
         "Failed operations: " + failedOps * 100.0 / POPULATION_SIZE + " %" + Environment.NewLine +
@@ -77 +78 @@
 
     private bool TreeHasAdfWithParameter(ISymbolicExpressionTree tree, int maxParameters) {
-      if(tree.Root.SubTrees.Count() != 2 ) return false;
+      if (tree.Root.SubTrees.Count() != 2) return false;
       var firstAdf = tree.Root.GetSubTree(1);
-      return firstAdf.Grammar.GetAllowedSymbols(firstAdf.Symbol, 0).Where(x => x is Argument).Count() < maxParameters;
+      return firstAdf.Grammar.GetAllowedChildSymbols(firstAdf.Symbol, 0).Where(x => x is Argument).Count() < maxParameters;
     }
   }

branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/ArgumentDeleterTest.cs

@@ -56 +56 @@
         ISymbolicExpressionTree tree = null;
         do {
-          tree = ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_LENGTH, MAX_TREE_DEPTH, 3, 3);
+          tree = ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_LENGTH, MAX_TREE_DEPTH);
+          SubroutineCreater.CreateSubroutine(random, tree, MAX_TREE_LENGTH, MAX_TREE_DEPTH, 3, 3);
         } while (!TreeHasAdfWithArguments(tree));
         var success = ArgumentDeleter.DeleteArgument(random, tree, 3, 3);
@@ -73 +74 @@
       if (tree.Root.SubTrees.Count() != 2) return false;
       var firstAdf = tree.Root.GetSubTree(1);
-      return firstAdf.Grammar.GetAllowedSymbols(firstAdf.Symbol, 0).Where(x => x is Argument).Count() >= 2;
+      return firstAdf.Grammar.GetAllowedChildSymbols(firstAdf.Symbol, 0).Where(x => x is Argument).Count() >= 2;
     }
   }

branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/ArgumentDuplicaterTest.cs

@@ -21 +21 @@
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
-using System.Collections.Generic;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Random;
@@ -56 +56 @@
         ISymbolicExpressionTree tree = null;
         do {
-          tree = ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_LENGTH, MAX_TREE_DEPTH, 3, 3);
-        } while(!HasAdfWithArguments(tree));
+          tree = ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_LENGTH, MAX_TREE_DEPTH);
+          SubroutineCreater.CreateSubroutine(random, tree, MAX_TREE_LENGTH, MAX_TREE_DEPTH, 3, 3);
+        } while (!HasAdfWithArguments(tree));
         var success = ArgumentDuplicater.DuplicateArgument(random, tree, 3, 3);
         Assert.IsTrue(success);
@@ -74 +75 @@
       if (tree.Root.SubTrees.Count() != 2) return false;
       var firstAdf = tree.Root.GetSubTree(1);
-      return firstAdf.Grammar.GetAllowedSymbols(firstAdf.Symbol, 0).Where(x => x is Argument).Count() == 1;
+      return firstAdf.Grammar.GetAllowedChildSymbols(firstAdf.Symbol, 0).Where(x => x is Argument).Count() == 1;
     }
   }

branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/ChangeNodeTypeManipulationTest.cs

@@ -55 +55 @@
       int failedEvents = 0;
       for (int i = 0; i < POPULATION_SIZE; i++) {
-        var tree = ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_LENGTH, MAX_TREE_DEPTH, 3, 3);
+        var tree = ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_LENGTH, MAX_TREE_DEPTH);
         string originalTree = formatter.Format(tree);
         ChangeNodeTypeManipulation.ChangeNodeType(random, tree);

branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/Grammars.cs

@@ -94 +94 @@
     }
 
-    private class SimpleArithmeticGrammar : DefaultSymbolicExpressionGrammar {
+    private class SimpleArithmeticGrammar : SymbolicExpressionGrammar {
       protected SimpleArithmeticGrammar(SimpleArithmeticGrammar original, Cloner cloner) : base(original, cloner) { }
       public SimpleArithmeticGrammar()
@@ -119 +119 @@
 
         foreach (var funSymb in functionSymbols) {
-          SetMinSubtreeCount(funSymb, 1);
-          SetMaxSubtreeCount(funSymb, 3);
+          SetSubtreeCount(funSymb, 1, 3);
         }
-        SetMinSubtreeCount(terminal, 0);
-        SetMaxSubtreeCount(terminal, 0);
+        SetSubtreeCount(terminal, 0, 0);
 
+        SetSubtreeCount(StartSymbol, 1, 1);
         // allow each symbol as child of the start symbol
         foreach (var symb in allSymbols) {
-          SetAllowedChild(StartSymbol, symb, 0);
+          AddAllowedChildSymbol(StartSymbol, symb);
+          AddAllowedChildSymbol(DefunSymbol, symb);
         }
 
         // allow each symbol as child of every other symbol (except for terminals that have maxSubtreeCount == 0)
-        foreach (var parent in allSymbols) {
-          for (int i = 0; i < GetMaxSubtreeCount(parent); i++)
-            foreach (var child in allSymbols) {
-              SetAllowedChild(parent, child, i);
-            }
+        foreach (var parent in functionSymbols) {
+          foreach (var child in allSymbols) {
+            AddAllowedChildSymbol(parent, child);
+          }
         }
       }
     }
 
-    public static ISymbolicExpressionTreeGrammar CreateSimpleArithmeticGrammar() {
-      var g = new GlobalSymbolicExpressionGrammar(new SimpleArithmeticGrammar());
-      g.MaxFunctionArguments = 0;
-      g.MinFunctionArguments = 0;
-      g.MaxFunctionDefinitions = 0;
-      g.MinFunctionDefinitions = 0;
+    public static ISymbolicExpressionGrammar CreateSimpleArithmeticGrammar() {
+      var g = new SimpleArithmeticGrammar();
+      g.MaximumFunctionArguments = 0;
+      g.MinimumFunctionArguments = 0;
+      g.MaximumFunctionDefinitions = 0;
+      g.MinimumFunctionDefinitions = 0;
       return g;
     }
 
-    public static ISymbolicExpressionTreeGrammar CreateArithmeticAndAdfGrammar() {
-      var g = new GlobalSymbolicExpressionGrammar(new SimpleArithmeticGrammar());
-      g.MaxFunctionArguments = 3;
-      g.MinFunctionArguments = 0;
-      g.MaxFunctionDefinitions = 3;
-      g.MinFunctionDefinitions = 0;
+    public static ISymbolicExpressionGrammar CreateArithmeticAndAdfGrammar() {
+      var g = new SimpleArithmeticGrammar();
+      g.MaximumFunctionArguments = 3;
+      g.MinimumFunctionArguments = 0;
+      g.MaximumFunctionDefinitions = 3;
+      g.MinimumFunctionDefinitions = 0;
       return g;
     }

branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/ProbabilisticTreeCreaterTest.cs

@@ -22 +22 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Random;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System.Diagnostics;
 
 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding_3._4.Tests {
@@ -56 +56 @@
       stopwatch.Start();
       for (int i = 0; i < POPULATION_SIZE; i++) {
-        randomTrees.Add(ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_LENGTH, MAX_TREE_DEPTH, 0, 0));
+        randomTrees.Add(ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_LENGTH, MAX_TREE_DEPTH));
       }
       stopwatch.Stop();
@@ -72 +72 @@
         Util.GetTerminalDistributionString(randomTrees) + Environment.NewLine
         );
-      Assert.IsTrue(Math.Round(1000.0 / (msPerRandomTreeCreation)) > 2000); // must achieve more than 2000 random trees / s
-    }
-
-
-    [TestMethod()]
-    public void ProbabilisticTreeCreaterWithAdfDistributionsTest() {
-      var randomTrees = new List<ISymbolicExpressionTree>();
-      var grammar = Grammars.CreateArithmeticAndAdfGrammar();
-      var random = new MersenneTwister(31415);
-      var stopwatch = new Stopwatch();
-      stopwatch.Start();
-      for (int i = 0; i < POPULATION_SIZE; i++) {
-        var tree = ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_LENGTH, MAX_TREE_DEPTH, 3, 3);
-        randomTrees.Add(tree);
-      }
-      stopwatch.Stop();
-      foreach (var tree in randomTrees)
-        Util.IsValid(tree);
-
-      double msPerRandomTreeCreation = stopwatch.ElapsedMilliseconds / (double)POPULATION_SIZE;
-
-      Console.WriteLine("ProbabilisticTreeCreator: " + Environment.NewLine +
-        msPerRandomTreeCreation + " ms per random tree (~" + Math.Round(1000.0 / (msPerRandomTreeCreation)) + "random trees / s)" + Environment.NewLine +
-        Util.GetSizeDistributionString(randomTrees, 105, 5) + Environment.NewLine +
-        Util.GetFunctionDistributionString(randomTrees) + Environment.NewLine +
-        Util.GetNumberOfSubTreesDistributionString(randomTrees) + Environment.NewLine +
-        Util.GetTerminalDistributionString(randomTrees) + Environment.NewLine
-        );
-
-      Assert.IsTrue(Math.Round(1000.0 / (msPerRandomTreeCreation)) > 2000); // must achieve more than 2000 random trees / s
+      Assert.IsTrue(Math.Round(1000.0 / (msPerRandomTreeCreation)) > 500); // must achieve more than 500 random trees / s
     }
   }

branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/ReplaceBranchManipulationTest.cs

@@ -54 +54 @@
       var random = new MersenneTwister(31415);
       for (int i = 0; i < POPULATION_SIZE; i++) {
-        var tree = ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_LENGTH, MAX_TREE_DEPTH, 3, 3);
+        var tree = ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_LENGTH, MAX_TREE_DEPTH);
+        SubroutineCreater.CreateSubroutine(random, tree, MAX_TREE_LENGTH, MAX_TREE_DEPTH, 3, 3);
         string originalTree = formatter.Format(tree);
         ReplaceBranchManipulation.ReplaceRandomBranch(random, tree, MAX_TREE_LENGTH, MAX_TREE_DEPTH);

branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/SubroutineCreaterTest.cs

@@ -21 +21 @@
 
 using System;
-using System.Linq;
 using System.Collections.Generic;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
@@ -55 +54 @@
       for (int i = 0; i < POPULATION_SIZE; i++) {
         ISymbolicExpressionTree tree = null;
-        do {
-          tree = ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_LENGTH, MAX_TREE_DEPTH, 3, 3);
-        } while ( !OneMoreAdfAllowed(tree));
+        tree = ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_LENGTH - 10, MAX_TREE_DEPTH);
         var success = SubroutineCreater.CreateSubroutine(random, tree, MAX_TREE_LENGTH, MAX_TREE_DEPTH, 3, 3);
         Assert.IsTrue(success);
@@ -70 +67 @@
         );
     }
-
-    private bool OneMoreAdfAllowed(ISymbolicExpressionTree tree) {
-      return tree.Length < 80 && tree.Root.SubTrees.Count() < 4;
-    }
   }
 }

branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/SubroutineDeleterTest.cs

@@ -21 +21 @@
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
-using System.Collections.Generic;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Random;
@@ -56 +56 @@
         ISymbolicExpressionTree tree = null;
         do {
-          tree = ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_LENGTH, MAX_TREE_DEPTH, 3, 3);
+          tree = ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_LENGTH, MAX_TREE_DEPTH);
+          SubroutineCreater.CreateSubroutine(random, tree, MAX_TREE_LENGTH, MAX_TREE_DEPTH, 3, 3);
+          SubroutineCreater.CreateSubroutine(random, tree, MAX_TREE_LENGTH, MAX_TREE_DEPTH, 3, 3);
         } while (!HasAtLeastOneAdf(tree));
         var success = SubroutineDeleter.DeleteSubroutine(random, tree, 3, 3);

branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/SubroutineDuplicaterTest.cs

@@ -21 +21 @@
 
 using System;
+using System.Collections.Generic;
 using System.Linq;
-using System.Collections.Generic;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Random;
@@ -56 +56 @@
         ISymbolicExpressionTree tree = null;
         do {
-          tree = ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_LENGTH, MAX_TREE_DEPTH, 3, 3);
+          tree = ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_LENGTH, MAX_TREE_DEPTH);
+          for (int j = random.Next(3); j < 3; j++)
+            SubroutineCreater.CreateSubroutine(random, tree, 100, 10, 3, 3);
         } while (!HasOneAdf(tree));
         var success = SubroutineDuplicater.DuplicateSubroutine(random, tree, 3, 3);

branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/SubtreeCrossoverTest.cs

@@ -56 +56 @@
 
       for (int i = 0; i < POPULATION_SIZE; i++) {
-        trees.Add(ProbabilisticTreeCreator.Create(random, grammar, 100, 10, 3, 3));
+        trees.Add(ProbabilisticTreeCreator.Create(random, grammar, 100, 10));
+        for (int j = random.Next(3); j < 3; j++)
+          SubroutineCreater.CreateSubroutine(random, trees[i], 100, 10, 3, 3);
       }
       Stopwatch stopwatch = new Stopwatch();
@@ -83 +85 @@
         );
 
-      Assert.IsTrue(Math.Round(1000.0 / (msPerCrossoverEvent)) > 2000); // must achieve more than 2000 x-overs/s
+      Assert.IsTrue(Math.Round(1000.0 / (msPerCrossoverEvent)) > 2500); // must achieve more than 1500 x-overs/s
     }
   }

branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/Util.cs

@@ -120 +120 @@
       foreach (var defunTreeNode in tree.Root.SubTrees.OfType<DefunTreeNode>()) {
         int arity = defunTreeNode.NumberOfArguments;
+
+        foreach (var argTreenode in defunTreeNode.IterateNodesPrefix().OfType<ArgumentTreeNode>()) {
+          Assert.IsTrue(argTreenode.SubtreesCount == 0);
+          Assert.IsTrue(((Argument)argTreenode.Symbol).ArgumentIndex < arity);
+        }
+
+        foreach (var argSymbol in Enumerable.Range(0, defunTreeNode.NumberOfArguments).Select(x => new Argument(x))) {
+          Assert.IsTrue(defunTreeNode.Grammar.ContainsSymbol(argSymbol));
+          Assert.IsTrue(defunTreeNode.Grammar.GetMaximumSubtreeCount(argSymbol) == 0);
+          Assert.IsTrue(defunTreeNode.Grammar.GetMinimumSubtreeCount(argSymbol) == 0);
+        }
+
         var invoke = new InvokeFunction(defunTreeNode.FunctionName);
         foreach (var otherRootNode in tree.Root.SubTrees) {
           if (otherRootNode.Grammar.ContainsSymbol(invoke)) {
-            Assert.IsTrue(otherRootNode.Grammar.GetMinSubtreeCount(invoke) == arity);
-            Assert.IsTrue(otherRootNode.Grammar.GetMaxSubtreeCount(invoke) == arity);
+            Assert.IsTrue(otherRootNode.Grammar.GetMinimumSubtreeCount(invoke) == arity);
+            Assert.IsTrue(otherRootNode.Grammar.GetMaximumSubtreeCount(invoke) == arity);
           }
         }
+
       }
-      //Assert.AreEqual(tree.Root.Symbol, tree.Root.Grammar.StartSymbol);
-      foreach (var subtree in tree.Root.SubTrees)
+      foreach (var subtree in tree.Root.SubTrees) {
         Assert.AreNotSame(subtree.Grammar, tree.Root.Grammar);
+        IsValid(subtree.Grammar);
+      }
+
+      IsValid(tree.Root.Grammar);
       IsValid(tree.Root);
+    }
+
+    public static void IsValid(ISymbolicExpressionTreeGrammar grammar) {
+      Assert.IsTrue(grammar.Symbols.Count() == grammar.Symbols.Distinct().Count());
+      foreach (ISymbol symbol in grammar.Symbols) {
+        Assert.IsTrue(grammar.GetMinimumSubtreeCount(symbol) <= grammar.GetMaximumExpressionLength(symbol));
+        Assert.IsTrue(grammar.GetAllowedChildSymbols(symbol).Count() == grammar.GetAllowedChildSymbols(symbol).Distinct().Count());
+        for (int i = 0; i < grammar.GetMaximumSubtreeCount(symbol); i++) {
+          Assert.IsTrue(grammar.GetAllowedChildSymbols(symbol, i).Count() == grammar.GetAllowedChildSymbols(symbol, i).Distinct().Count());
+        }
+      }
     }
 
@@ -138 +165 @@
                             where symb.Name == treeNode.Symbol.Name
                             select symb).SingleOrDefault();
-      Assert.IsTrue(treeNode.SubTrees.Count() >= treeNode.Grammar.GetMinSubtreeCount(matchingSymbol));
-      Assert.IsTrue(treeNode.SubTrees.Count() <= treeNode.Grammar.GetMaxSubtreeCount(matchingSymbol));
+      Assert.IsTrue(treeNode.SubTrees.Count() >= treeNode.Grammar.GetMinimumSubtreeCount(matchingSymbol));
+      Assert.IsTrue(treeNode.SubTrees.Count() <= treeNode.Grammar.GetMaximumSubtreeCount(matchingSymbol));
       Assert.AreNotEqual(0.0, matchingSymbol.InitialFrequency); // check that no deactivated symbols occur in the tree
       for (int i = 0; i < treeNode.SubTrees.Count(); i++) {
-        Assert.IsTrue(treeNode.Grammar.GetAllowedSymbols(treeNode.Symbol, i).Select(x => x.Name).Contains(treeNode.GetSubTree(i).Symbol.Name));
+        Assert.IsTrue(treeNode.Grammar.GetAllowedChildSymbols(treeNode.Symbol, i).Select(x => x.Name).Contains(treeNode.GetSubTree(i).Symbol.Name));
         IsValid(treeNode.GetSubTree(i));
       }