Index: /applications/robust/main.cpp
===================================================================
--- /applications/robust/main.cpp (revision 1219)
+++ /applications/robust/main.cpp (revision 1220)
@@ -15,9 +15,11 @@
 int main ( int argc, char* argv[] ) {
 	
-	emlig* emlig1 = new emlig(3);	
+	emlig* emlig1 = new emlig(8);	
 
 	for(int i = 0;i<500;i++)
 	{
-		double condition[4];		
+		cout << "Step:" << i << endl;
+
+		double condition[9];		
 
 		condition[0] = rand()/1000.0;
@@ -25,6 +27,12 @@
 		condition[2] = rand()/1000.0;
 		condition[3] = rand()/1000.0;
+		condition[4] = rand()/1000.0;
+		condition[5] = rand()/1000.0;
+		condition[6] = rand()/1000.0;
+		condition[7] = rand()/1000.0;
+		condition[8] = rand()/1000.0;
+		
 
-		vec* condition_vec = new vec(condition,4);
+		vec* condition_vec = new vec(condition,9);
 		emlig1->add_condition(*condition_vec);
 
Index: /applications/robust/robustlib.h
===================================================================
--- /applications/robust/robustlib.h (revision 1219)
+++ /applications/robust/robustlib.h (revision 1220)
@@ -12,4 +12,5 @@
 #include <vector>
 #include <list>
+#include <set>
 #include <algorithm>
 	
@@ -48,5 +49,5 @@
 
 	/// All the vertices of the given polyhedron
-	list<vertex*> vertices;
+	set<vertex*> vertices;
 
 	/// A list used for storing children that lie in the positive region related to a certain condition
@@ -62,4 +63,8 @@
 
 	list<polyhedron*> totallyneutralchildren;
+
+	set<vertex*> positiveneutralvertices;
+
+	set<vertex*> negativeneutralvertices;
 
 	bool totally_neutral;
@@ -395,5 +400,5 @@
 			double product = 0;
 
-			list<vertex*>::iterator vertex_ref = horiz_ref->vertices.begin();
+			set<vertex*>::iterator vertex_ref = horiz_ref->vertices.begin();
 
 			do
@@ -497,8 +502,11 @@
 						{
 						case 1:
-							current_parent->positivechildren.push_back(sender);							
+							current_parent->positivechildren.push_back(sender);
+							current_parent->positiveneutralvertices.insert(sender->vertices.begin(),sender->vertices.end());
 						break;
 						case 0:
-							current_parent->neutralchildren.push_back(sender);							
+							current_parent->neutralchildren.push_back(sender);
+							current_parent->positiveneutralvertices.insert(sender->positiveneutralvertices.begin(),sender->positiveneutralvertices.end());
+							current_parent->negativeneutralvertices.insert(sender->negativeneutralvertices.begin(),sender->negativeneutralvertices.end());
 
 							if(current_parent->totally_neutral == NULL)
@@ -518,5 +526,6 @@
 						break;
 						case -1:
-							current_parent->negativechildren.push_back(sender);							
+							current_parent->negativechildren.push_back(sender);
+							current_parent->negativeneutralvertices.insert(sender->vertices.begin(),sender->vertices.end());
 						break;
 						}
@@ -558,4 +567,6 @@
 								current_parent->totallyneutralchildren.clear();
 								current_parent->totallyneutralgrandchildren.clear();
+								current_parent->positiveneutralvertices.clear();
+								current_parent->negativeneutralvertices.clear();
 								current_parent->totally_neutral = NULL;
 								current_parent->kids_rel_addresses.clear();
@@ -718,4 +729,7 @@
 
 						current_vertex->raise_multiplicity();
+
+						current_vertex->negativeneutralvertices.insert(current_vertex);
+						current_vertex->positiveneutralvertices.insert(current_vertex);
 					}					
 				}
@@ -781,4 +795,6 @@
 					{
 						(*grand_ref)->parents.push_back(new_totally_neutral_child);
+
+						new_totally_neutral_child->vertices.insert((*grand_ref)->vertices.begin(),(*grand_ref)->vertices.end());
 					}
 
@@ -816,5 +832,5 @@
 					{
 						(*child_ref)->parents.remove(current_polyhedron);
-						(*child_ref)->parents.push_back(positive_poly);
+						(*child_ref)->parents.push_back(positive_poly);						
 					}					
 
@@ -832,4 +848,10 @@
 												current_polyhedron->negativechildren.begin(),
 															current_polyhedron->negativechildren.end());
+
+					positive_poly->vertices.insert(current_polyhedron->positiveneutralvertices.begin(),current_polyhedron->positiveneutralvertices.end());
+					positive_poly->vertices.insert(new_totally_neutral_child->vertices.begin(),new_totally_neutral_child->vertices.end());
+
+					negative_poly->vertices.insert(current_polyhedron->negativeneutralvertices.begin(),current_polyhedron->negativeneutralvertices.end());
+					negative_poly->vertices.insert(new_totally_neutral_child->vertices.begin(),new_totally_neutral_child->vertices.end());
 
 					statistic.append_polyhedron(k-1, new_totally_neutral_child);
@@ -868,5 +890,5 @@
 		// It has itself as a vertex. There will be a nice use for this when the vertices of its parents are searched in
 		// the recursive creation procedure below.
-		origin->vertices.push_back(origin);
+		origin->vertices.insert(origin);
 
 		/*
@@ -904,6 +926,6 @@
 			vertex *new_point2 = new vertex(origin_coord2);
 
-			new_point1->vertices.push_back(new_point1);
-			new_point2->vertices.push_back(new_point2);
+			new_point1->vertices.insert(new_point1);
+			new_point2->vertices.insert(new_point2);
 			
 			//*********************************************************************************************************
@@ -992,18 +1014,30 @@
 					// between each polyhedron and its offspring (comming from the copy) and a parent has all the
 					// vertices of its child plus more.
-					for(list<vertex*>::iterator vertex_ref = horiz_ref->vertices.begin();vertex_ref!=horiz_ref->vertices.end();vertex_ref++)
-					{
-						current_copy1->vertices.push_back(*vertex_ref);
-						current_copy2->vertices.push_back(*vertex_ref);						
+					for(set<vertex*>::iterator vertex_ref = horiz_ref->vertices.begin();vertex_ref!=horiz_ref->vertices.end();vertex_ref++)
+					{
+						current_copy1->vertices.insert(*vertex_ref);
+						current_copy2->vertices.insert(*vertex_ref);						
 					}
 					
 					// The only new vertex of the offspring should be the newly created point.
-					current_copy1->vertices.push_back(new_point1);
-					current_copy2->vertices.push_back(new_point2);
+					current_copy1->vertices.insert(new_point1);
+					current_copy2->vertices.insert(new_point2);
 					
 					// This method guarantees that each polyhedron is already triangulated, therefore its triangulation
 					// is only one set of vertices and it is the set of all its vertices.
-					current_copy1->triangulations.push_back(current_copy1->vertices);
-					current_copy2->triangulations.push_back(current_copy2->vertices);
+					list<vertex*> triangulation1;
+					list<vertex*> triangulation2;
+
+					set<vertex*>::iterator copy2_ref = current_copy2->vertices.begin();
+					for(set<vertex*>::iterator copy1_ref = current_copy1->vertices.begin(); copy1_ref != current_copy1->vertices.end(); copy1_ref++)
+					{
+						triangulation1.push_back(*copy1_ref);
+						triangulation2.push_back(*copy2_ref);
+
+						copy2_ref++;
+					}
+
+					current_copy1->triangulations.push_back(triangulation1);
+					current_copy2->triangulations.push_back(triangulation2);
 					
 					// Now we have copied the polyhedron and we have to copy all of its relations. Because we are copying
