Index: /trunk/sources/HeuristicLab.Constraints/AllSubOperatorsTypeConstraintView.cs
===================================================================
--- /trunk/sources/HeuristicLab.Constraints/AllSubOperatorsTypeConstraintView.cs	(revision 429)
+++ /trunk/sources/HeuristicLab.Constraints/AllSubOperatorsTypeConstraintView.cs	(revision 430)
@@ -87,6 +87,5 @@
     #endregion
 
-    #region Drag Events   
-
+    #region Drag Events
     private void listView_DragDrop(object sender, DragEventArgs e) {
       if(e.Effect != DragDropEffects.None) {
@@ -105,5 +104,4 @@
     }
 
-
     private void listView_DragEnter(object sender, DragEventArgs e) {
       this.FindForm().BringToFront();
@@ -117,5 +115,4 @@
       }
     }
-
 
     private void listView_DragOver(object sender, DragEventArgs e) {
Index: /trunk/sources/HeuristicLab.Constraints/SubOperatorsConstraintAnalyser.cs
===================================================================
--- /trunk/sources/HeuristicLab.Constraints/SubOperatorsConstraintAnalyser.cs	(revision 429)
+++ /trunk/sources/HeuristicLab.Constraints/SubOperatorsConstraintAnalyser.cs	(revision 430)
@@ -91,11 +91,7 @@
     private static bool InSet(IOperator op, ICollection<IOperator> set) {
       foreach(IOperator element in set) {
-        if(element==op ||
-          ((StringData)element.GetVariable("TypeId").Value).Data ==
-          ((StringData)op.GetVariable("TypeId").Value).Data) {
+        if(element == op)
           return true;
-        }
       }
-
       return false;
     }
@@ -132,5 +128,5 @@
         }
       }
-      
+
       public override void Visit(OrConstraint constraint) {
         base.Visit(constraint);
Index: /trunk/sources/HeuristicLab.Constraints/SubOperatorsTypeConstraint.cs
===================================================================
--- /trunk/sources/HeuristicLab.Constraints/SubOperatorsTypeConstraint.cs	(revision 429)
+++ /trunk/sources/HeuristicLab.Constraints/SubOperatorsTypeConstraint.cs	(revision 430)
@@ -55,5 +55,5 @@
       // check if already in the list of allowed functions
       foreach(IOperator existingOp in subOperators) {
-        if (IsOperatorTypeEqual(existingOp, op)) {
+        if(existingOp == op) {
           return;
         }
@@ -66,5 +66,5 @@
       IOperator matchingOperator = null;
       foreach(IOperator existingOp in subOperators) {
-        if(IsOperatorTypeEqual(existingOp, op)) {
+        if(existingOp == op) {
           matchingOperator = existingOp;
           break;
@@ -72,5 +72,5 @@
       }
 
-      if (matchingOperator != null) {
+      if(matchingOperator != null) {
         subOperators.Remove(matchingOperator);
       }
@@ -79,11 +79,11 @@
     public override bool Check(IItem data) {
       IOperator op = data as IOperator;
-      if (data == null) return false;
+      if(data == null) return false;
 
       if(op.SubOperators.Count <= subOperatorIndex.Data) {
         return false;
       }
-      
-      return subOperators.Exists(delegate(IOperator curOp) { return IsOperatorTypeEqual(curOp, op.SubOperators[subOperatorIndex.Data]); });
+
+      return subOperators.Exists(delegate(IOperator curOp) { return curOp == op.SubOperators[subOperatorIndex.Data]; });
     }
 
@@ -108,5 +108,5 @@
 
     #region persistence
-    public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid,IStorable> persistedObjects) {
+    public override XmlNode GetXmlNode(string name, XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
       XmlNode node = base.GetXmlNode(name, document, persistedObjects);
       XmlNode indexNode = PersistenceManager.Persist("SubOperatorIndex", subOperatorIndex, document, persistedObjects);
@@ -121,5 +121,5 @@
     }
 
-    public override void Populate(XmlNode node, IDictionary<Guid,IStorable> restoredObjects) {
+    public override void Populate(XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
       base.Populate(node, restoredObjects);
       subOperatorIndex = (IntData)PersistenceManager.Restore(node.SelectSingleNode("SubOperatorIndex"), restoredObjects);
@@ -131,8 +131,4 @@
     #endregion persistence
 
-
-    private bool IsOperatorTypeEqual(IOperator f, IOperator g) {
-      return ((StringData)f.GetVariable("TypeId").Value).Data == ((StringData)g.GetVariable("TypeId").Value).Data;
-    }
   }
 }
Index: /trunk/sources/HeuristicLab.StructureIdentification/GPOperatorGroup.cs
===================================================================
--- /trunk/sources/HeuristicLab.StructureIdentification/GPOperatorGroup.cs	(revision 429)
+++ /trunk/sources/HeuristicLab.StructureIdentification/GPOperatorGroup.cs	(revision 430)
@@ -41,9 +41,4 @@
       var localVariableInfos = op.VariableInfos.Where(f => f.Local);
 
-      // add a new typeid if necessary
-      if(op.GetVariable(GPOperatorLibrary.TYPE_ID) == null) {
-        op.AddVariable(new Variable(GPOperatorLibrary.TYPE_ID, new StringData(Guid.NewGuid().ToString())));
-      }
-
       if(op.GetVariable(GPOperatorLibrary.MIN_TREE_HEIGHT) == null) {
         op.AddVariable(new Variable(GPOperatorLibrary.MIN_TREE_HEIGHT, new IntData(-1)));
@@ -62,6 +57,6 @@
 
 
-    private Dictionary<string, int> minTreeHeight = new Dictionary<string, int>();
-    private Dictionary<string, int> minTreeSize = new Dictionary<string, int>();
+    private Dictionary<IOperator, int> minTreeHeight = new Dictionary<IOperator, int>();
+    private Dictionary<IOperator, int> minTreeSize = new Dictionary<IOperator, int>();
     private SubOperatorsConstraintAnalyser constraintAnalyser = new SubOperatorsConstraintAnalyser();
 
@@ -101,8 +96,7 @@
 
     private int RecalculateMinimalTreeSize(IOperator op) {
-      string typeId = GetTypeId(op);
       // check for memoized value
-      if(minTreeSize.ContainsKey(typeId)) {
-        return minTreeSize[typeId];
+      if(minTreeSize.ContainsKey(op)) {
+        return minTreeSize[op];
       }
 
@@ -112,5 +106,5 @@
       // no suboperators possible => minimalTreeSize == 1 (the current node)
       if(minArity == 0 && maxArity == 0) {
-        minTreeSize[typeId] = 1;
+        minTreeSize[op] = 1;
         return 1;
       }
@@ -121,5 +115,5 @@
 
       // mark the currently processed operator to prevent infinite recursions and stack overflow
-      minTreeSize[typeId] = 9999;
+      minTreeSize[op] = 9999;
       for(int i = 0; i < minArity; i++) {
         // calculate the minTreeSize of all allowed sub-operators 
@@ -136,5 +130,5 @@
       }
 
-      minTreeSize[typeId] = subTreeSizeSum + 1;
+      minTreeSize[op] = subTreeSizeSum + 1;
       return subTreeSizeSum + 1;
     }
@@ -142,8 +136,7 @@
 
     private int RecalculateMinimalTreeHeight(IOperator op) {
-      string typeId = GetTypeId(op);
       // check for memoized value
-      if(minTreeHeight.ContainsKey(typeId)) {
-        return minTreeHeight[typeId];
+      if(minTreeHeight.ContainsKey(op)) {
+        return minTreeHeight[op];
       }
 
@@ -153,5 +146,5 @@
       // no suboperators possible => minimalTreeHeight == 1
       if(minArity == 0 && maxArity == 0) {
-        minTreeHeight[typeId] = 1;
+        minTreeHeight[op] = 1;
         return 1;
       }
@@ -162,5 +155,5 @@
 
       // mark the currently processed operator to prevent infinite recursions leading to stack overflow
-      minTreeHeight[typeId] = 9999;
+      minTreeHeight[op] = 9999;
       for(int i = 0; i < minArity; i++) {
         // calculate the minTreeHeight of all possible sub-operators.
@@ -182,5 +175,5 @@
       }
 
-      minTreeHeight[typeId] = maxSubTreeHeight + 1;
+      minTreeHeight[op] = maxSubTreeHeight + 1;
       return maxSubTreeHeight + 1;
     }
@@ -200,8 +193,4 @@
     }
 
-    private string GetTypeId(IOperator op) {
-      return ((StringData)op.GetVariable(GPOperatorLibrary.TYPE_ID).Value).Data;
-    }
-
     public override void AddSubGroup(IOperatorGroup group) {
       throw new NotSupportedException();
@@ -210,5 +199,4 @@
     public override void RemoveOperator(IOperator op) {
       base.RemoveOperator(op);
-      op.RemoveVariable(GPOperatorLibrary.TYPE_ID);
       op.RemoveVariable(GPOperatorLibrary.MIN_TREE_SIZE);
       op.RemoveVariable(GPOperatorLibrary.MIN_TREE_HEIGHT);
Index: /trunk/sources/HeuristicLab.StructureIdentification/GPOperatorLibrary.cs
===================================================================
--- /trunk/sources/HeuristicLab.StructureIdentification/GPOperatorLibrary.cs	(revision 429)
+++ /trunk/sources/HeuristicLab.StructureIdentification/GPOperatorLibrary.cs	(revision 430)
@@ -30,5 +30,4 @@
   public class GPOperatorLibrary : ItemBase, IOperatorLibrary, IEditable  {
     // constants for variable names
-    internal const string TYPE_ID = "TypeId";
     internal const string MIN_TREE_HEIGHT = "MinTreeHeight";
     internal const string MIN_TREE_SIZE = "MinTreeSize";
