dep-selector-libgecode 1.0.0.alpha.0

data/ext/libgecode3/vendor/gecode-3.7.3/contribs/qecode/UnblockableBranching.hh

@@ -0,0 +1,34 @@
+/****   , [ UnblockableBranching.hh ], 
+Copyright (c) 2009 Universite d'Orleans - Jeremie Vautard 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+ *************************************************************************/
+#ifndef __QECODE_UNBLOCKABLE_BRANCHING__
+#define __QECODE_UNBLOCKABLE_BRANCHING__
+
+#include "myspace.hh"
+
+class UnblockableBranching {
+public:
+    virtual ~UnblockableBranching() {}
+    virtual void branch(MySpace* s,IntVarArgs ivars, BoolVarArgs bvars)=0;
+};
+
+#endif
+

data/ext/libgecode3/vendor/gecode-3.7.3/contribs/qecode/UnblockableViewValBranching.cc

@@ -0,0 +1,61 @@
+/****   , [ UnblockableViewValBranching.cc ], 
+Copyright (c) 2009 Universite d'Orleans - Jeremie Vautard 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+ *************************************************************************/
+
+#include "UnblockableViewValBranching.hh"
+#include <iostream>
+
+using namespace std;
+
+UnblockableViewValBranching::UnblockableViewValBranching(IntVarBranch vrb,IntValBranch vlb,bool booleans_before) {
+    ivrb=vrb;
+    bvrb=vrb;
+    ivlb=vlb;
+    bvlb=vlb;
+    before=booleans_before;
+}
+
+UnblockableViewValBranching::UnblockableViewValBranching(IntVarBranch Ivrb,IntValBranch Ivlb,IntVarBranch Bvrb,IntValBranch Bvlb,bool booleans_before) {
+    ivrb=Ivrb;
+    ivlb=Ivlb;
+    bvrb=Bvrb;
+    bvlb=Bvlb;
+    before=booleans_before;
+}
+
+void UnblockableViewValBranching::branch(MySpace* s,IntVarArgs ivars, BoolVarArgs bvars) {
+    if (before) {
+        if (bvars.size() != 0) {
+            Gecode::branch(*s,bvars,bvrb,bvlb);
+        }
+        if (ivars.size() != 0) {
+            Gecode::branch(*s,ivars,ivrb,ivlb);
+        }
+    }
+    else {
+        if (ivars.size() != 0) {
+            Gecode::branch(*s,ivars,ivrb,ivlb);
+        }
+        if (bvars.size() != 0) {
+            Gecode::branch(*s,bvars,bvrb,bvlb);
+        }
+    }
+}

data/ext/libgecode3/vendor/gecode-3.7.3/contribs/qecode/UnblockableViewValBranching.hh

@@ -0,0 +1,45 @@
+/****   , [ UnblockableViewValBranching.hh ], 
+Copyright (c) 2009 Universite d'Orleans - Jeremie Vautard 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+ *************************************************************************/
+#ifndef __QECODE_UNBLOK_VIEWVAL_BRANCH__
+#define __QECODE_UNBLOK_VIEWVAL_BRANCH__
+
+#include "qecode.hh"
+#include "gecode/minimodel.hh"
+#include "qecode.hh"
+#include "UnblockableBranching.hh"
+
+class QECODE_VTABLE_EXPORT UnblockableViewValBranching : public UnblockableBranching {
+private :
+    IntVarBranch ivrb;
+    IntVarBranch bvrb;
+    IntValBranch ivlb;
+    IntValBranch bvlb;
+    bool before;
+    
+public :
+    QECODE_EXPORT UnblockableViewValBranching(IntVarBranch vrb,IntValBranch vlb,bool booleans_before);
+    QECODE_EXPORT UnblockableViewValBranching(IntVarBranch Ivrb,IntValBranch Ivlb,IntVarBranch Bvrb,IntValBranch Bvlb,bool booleans_before);
+    QECODE_EXPORT virtual void branch(MySpace* s,IntVarArgs ivars, BoolVarArgs bvars);
+};
+
+#endif
+

data/ext/libgecode3/vendor/gecode-3.7.3/contribs/qecode/Work.cc

@@ -0,0 +1,48 @@
+/************************************************************ Work.cc
+ Copyright (c) 2010 Universite de Caen Basse Normandie - Jeremie Vautard 
+ 
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+ 
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+ *************************************************************************/
+
+#include "Work.hh"
+QWork::QWork(int scope,vector<int> root,Gecode::Search::Engine* todo){
+	this->theRoot = root;
+	this->remaining = todo;
+	this->scope = scope;
+	this->wait = this->stop = false;
+}
+
+QWork::~QWork() {}
+
+QWork QWork::Wait() {
+	QWork ret;
+	ret.wait=true;
+	ret.stop=false;
+	ret.remaining=NULL;
+	return ret;
+}
+
+QWork QWork::Stop() {
+	QWork ret;
+	ret.wait=false;
+	ret.stop=true;
+	ret.remaining=NULL;
+	return ret;
+}
+

data/ext/libgecode3/vendor/gecode-3.7.3/contribs/qecode/Work.hh

@@ -0,0 +1,64 @@
+/************************************************************ Work.hh
+Copyright (c) 2010 Universite de Caen Basse Normandie - Jeremie Vautard 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+ *************************************************************************/
+#ifndef __QECODE_QWORK__
+#define __QECODE_QWORK__
+#include<vector>
+#include "Strategy.hh"
+#include "qecode.hh"
+#include "gecode/support.hh"
+#include "gecode/search.hh"
+#include "gecode/search/support.hh"
+#include "gecode/search/sequential/dfs.hh"
+
+using namespace std;
+using namespace Gecode;
+using namespace Gecode::Support;
+
+class QECODE_VTABLE_EXPORT QWork {
+private:
+	bool wait;
+  bool stop;
+	vector<int> theRoot;
+  Gecode::Search::Engine* remaining;
+	int scope;
+public: 
+  QECODE_EXPORT QWork(){wait=stop=0; remaining=NULL; scope=-1;} ///< creates a dummy work. Don't try to solve it.
+  QECODE_EXPORT QWork(int scope,vector<int> root,Gecode::Search::Engine* todo);
+  QECODE_EXPORT ~QWork();
+	
+  QECODE_EXPORT static QWork Wait();
+  QECODE_EXPORT static QWork Stop();
+	
+  QECODE_EXPORT forceinline bool isWait() {return wait;}
+  QECODE_EXPORT forceinline bool isStop() {return stop;}
+	
+  QECODE_EXPORT forceinline Gecode::Search::Engine* getRemaining() {return this->remaining;}
+  QECODE_EXPORT vector<int> root() {
+    vector<int> ret=this->theRoot;
+    return ret;
+  }
+  QECODE_EXPORT forceinline int getScope() {return this->scope;}
+  QECODE_EXPORT forceinline void clean() {if (!wait && !stop) delete remaining;}
+};
+
+
+#endif

data/ext/libgecode3/vendor/gecode-3.7.3/contribs/qecode/WorkComparators.hh

@@ -0,0 +1,67 @@
+/*
+ *  WorkComparators.hh
+ *  
+ *
+ *  Created by Jérémie Vautard on 31/03/10.
+ *  Copyright 2010 Université d'Orléans. All rights reserved.
+ *
+ */
+
+#include "WorkManager.hh"
+#include "QCOPPlus.hh"
+
+class BidonComparator : public WorkComparator {
+	public : 
+  virtual bool cmp(QWork a,QWork b) {
+    return false;
+  }
+};
+
+class DeepFirstComparator : public WorkComparator {
+	public : 
+  virtual bool cmp(QWork a,QWork b) {
+    if (a.root().size() > b.root().size()) return true;
+    if (a.root().size() < b.root().size()) return false;
+    return ((a.getRemaining()) < (b.getRemaining()));
+  }
+};
+
+class QuantifierThenDepthComparator : public WorkComparator {
+	private :
+	Qcop* problem;
+	bool existsFirst;
+	bool deepestFirst;
+	
+	public : 
+	QuantifierThenDepthComparator(Qcop* p,bool existsFirst,bool deepestFirst) { 
+		this->problem = p;
+		this->existsFirst = existsFirst;
+		this->deepestFirst = deepestFirst;
+	}	
+	virtual bool cmp(QWork a,QWork b) {
+		bool q1 = (problem->qt_of_var(a.root().size()) != existsFirst);
+		bool q2 = (problem->qt_of_var(b.root().size()) != existsFirst);
+		if (q1 && !q2) return true;
+		if (!q1 && q2) return false;
+		int d1 = a.root().size();
+		int d2 = b.root().size();
+		if ( (d1 < d2) != deepestFirst) return true;
+		return false;
+	}
+};
+
+class DepthComparator : public WorkComparator {
+	private : 
+	bool deepestFirst;
+	public : 
+	DepthComparator(bool deepestFirst) {
+		this->deepestfirst = deepestFirst;
+	}
+	
+	virtual bool cmp(QWork a,QWork b) {
+		int d1 = a.root().size();
+		int d2 = b.root().size();
+		if ( (d1 < d2) != deepestFirst) return true;
+		return false;
+	}
+};

data/ext/libgecode3/vendor/gecode-3.7.3/contribs/qecode/WorkManager.cc

@@ -0,0 +1,376 @@
+/************************************************************ WorkManager.cc
+ Copyright (c) 2010 Universite d'Orleans - Jeremie Vautard 
+ 
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+ 
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+ 
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+*************************************************************************/
+
+#include "WorkManager.hh"
+bool isPrefix(vector<int> prefix,vector<int> a) {
+  if (a.size() < prefix.size())
+    return false;
+  else
+    for (unsigned int i=0;i<prefix.size();i++) 
+      if (prefix[i] != a[i])
+	return false;
+	
+  return true;
+}
+
+WorkPool::WorkPool(WorkComparator* a) {
+  cmp=a;
+}
+
+void WorkPool::push(QWork q) {
+  list<QWork>::iterator i = l.begin();
+  while (i != l.end() && cmp->cmp((*i),q)) i++;
+  l.insert(i,q);
+}
+
+QWork WorkPool::pop()  {
+  QWork ret=l.front();
+  l.pop_front();
+  return ret;
+}
+
+void WorkPool::trash(vector<int> prefix) {
+  //    cout<<"      WPT called on ";
+  //if (prefix.empty()) cout<<"empty";
+  //for (int i=0;i< prefix.size();i++) cout<<prefix[i]<<" ";
+  //cout<<endl;
+  //  cout<<"debug "<<l.size()<<endl;  
+
+    list<QWork>::iterator i=l.begin(); 
+   while (!(i == l.end())) {
+  //  cout<<"| ";
+     //   cout.flush();
+    bool avance=true;
+    vector<int> root = (*i).root();
+    if (isPrefix(prefix,root)) {
+      (*i).clean();
+      i=l.erase(i);
+      avance = false;
+      // cout<<"erased";
+    }
+    if (avance) i++;
+  }
+   //cout<<endl;
+
+  //for (list<QWork>::iterator i=l.begin();i != l.end();i++) {
+  //vector<int> root = (*i).root();
+    //if (isPrefix(prefix,root)) {
+      // cout<<"      trashing ";
+      // if (root.empty()) cout<<"empty";
+      // for (int j=0;j< root.size();j++) cout<<root[j]<<" ";
+      // cout<<endl;
+      //(*i).clean();
+      //l.erase(i);
+      //i--;
+      //}
+    // }
+}
+
+
+void WorkManager::getNewWorks() {
+  // cout<<"WM asking for "<<actives.front()<<" to stopandreturn"<<endl;
+  (actives.front())->stopAndReturn();
+}
+
+WorkManager::WorkManager(Qcop* p,WorkComparator* c) : Todos(c) {
+  problem=p;
+  vector<int> v;
+  MySpace* espace=p->getSpace(0);
+  Options o;
+  Engine* solutions = new WorkerToEngine<Gecode::Search::Sequential::DFS>(espace,sizeof(MySpace),o);
+  QWork first(0,v,solutions);
+  Todos.push(first);
+  finished=false;
+  S = Strategy::Dummy();
+  S.attach(Strategy::Stodo());
+}
+
+QWork WorkManager::getWork(AQWorker* worker) {
+  //  clock_t start = clock();
+  //  cout<<worker<<" WAIT getWork "<<start<<endl;
+  mex.acquire();
+  //  clock_t stop = clock();
+  // cout<<worker<<" CONT getWork "<<stop<<" waited "<<(stop-start)<<endl;
+
+  //  cout<<"G ";cout.flush();
+  // cout<<"WM getwork acquired"<<endl;
+  QWork ret;
+  if (Todos.empty()) {
+    // cout<<"WM : Todos was empty"<<endl;
+    if (actives.empty()) {
+      // cout<<"WM : Actives was empty, stopping worker."<<endl;
+      ret = QWork::Stop();	
+      finished=true;
+    }
+    else {
+      getNewWorks();
+      // cout<<"WM sleeping worker"<<endl;
+      ret = QWork::Wait();
+      idles.push_back(worker);
+    }
+  }
+  else {
+    // cout<<"WM : giving work ";
+    ret = Todos.top();
+    Todos.pop();
+    // if (ret.root().empty()) cout<<"empty";
+    // for (int i=0;i< ret.root().size();i++) cout<<ret.root()[i]<<" ";
+    // cout<<endl;
+		
+    actives.push_back(worker); 
+  }
+  // cout<<"WM getwork release"<<endl;
+  mex.release();
+  return ret;
+}
+
+void WorkManager::returnWork(AQWorker* worker,Strategy ret,list<QWork> todo,vector<int> position) { 
+  // If the worker is not among the actives ones, ignore his job. Else, withdraw it from the active workers
+  // and process its result
+
+  //  clock_t start = clock();
+  //  cout<<worker<<" WAIT returnWork "<<start<<endl;
+  mex.acquire();
+  //  clock_t stop = clock();
+  // cout<<worker<<" CONT returnWork "<<stop<<" waited "<<(stop-start)<<endl;
+  // cout<<"RW returnWork acquired"<<endl;
+  // cout<<"returning work at ";
+  // if (position.empty()) cout<<"empty";
+  // for (int i=0;i< position.size();i++) cout<<position[i]<<" ";
+  // cout<<endl;
+
+  bool ok=false;
+  list<AQWorker*>::iterator i = actives.begin();
+  while (!(i == actives.end()) && !ok) {
+    bool avance=true;
+    if ((*i) == worker) {
+      // cout<<"RW Worker found in actives. Deleting"<<endl;
+      i=actives.erase(i);
+      avance = false;
+      ok=true;
+    }
+    if (avance) ++i;
+  }
+  if (!ok) {
+    // cout<<"RW Ignoring work"<<endl;
+    // when ignoring the result, we have to delete every search engine from the eventual to-do works it did
+    for (list<QWork>::iterator j = todo.begin();j != todo.end();j++) {
+      (*j).clean();
+    }
+    // cout<<"RW release"<<endl;
+    mex.release();
+    return;
+  }
+	
+  // processing results...
+	
+  // adding todo to Todos
+	
+  // going to father of substrategy
+  bool acceptable = true;
+  Strategy father = S.getSubStrategy(position);
+  if (father.isDummy() && (father.id() != S.id())) {
+    // cout<<"ERROR : RW Work was not in current strategy. Ignoring."<<endl;
+    acceptable=false;
+  }
+  // remove the Todo node that marked this work
+  if (acceptable) { 
+    // cout<<" RW Father position is ";
+    // vector<int> checkPosition = father.getPosition();
+    // if (checkPosition.empty()) cout<<"empty";
+    // for (int i=0;i< checkPosition.size();i++) cout<<checkPosition[i]<<" ";
+    // cout<<endl;
+		
+    for (list<QWork>::iterator j = todo.begin();j != todo.end();j++) {
+      //		cout<<"WM todo + 1"<<endl;
+      if (!idles.empty()) {
+	//			cout<<"WM waking an idle"<<endl;
+	AQWorker* towake = idles.back();
+	idles.pop_back();
+	towake->wake();
+      }
+      // cout<<"RW Adding work in Todos : ";
+      // if ((*j).root().empty()) cout<<"empty";
+      // for (int i=0;i< (*j).root().size();i++) cout<<(*j).root()[i]<<" ";
+      // cout<<endl;
+			
+      Todos.push(*j);
+    }
+		
+    for (unsigned int i=0;i<father.degree();i++) {
+      if (father.getChild(i).isTodo()) {
+	// cout<<"RW deleting Todo node"<<endl;
+	father.detach(i);
+	i--;
+      }
+    }
+		
+		
+    if (!ret.isComplete()) { // still work to do...
+      // attach the (incomplete) substrategy
+      // cout<<"RW returned work was incomplete. Attaching"<<endl;
+      father.attach(ret);
+    }
+    else if (!ret.isFalse()) { // complete substrategy
+      // attach the (complete) substrategy
+      // recursively update node	
+      // cout<<"RW returned work was true. Attaching and updating"<<endl;
+      father.attach(ret);
+      updateTrue(father);
+    }
+    else { //ret is false
+      // cout<<"RW returned work was false. Attaching and updating"<<endl;
+      int myscope = problem->qt_of_var(position.size() + 1);
+      if (myscope) { // if ret was a forall node, the father itself is false
+	// cout<<"RW work is A -> father is false"<<endl;
+	updateFalse(father);
+      }
+      else if (father.degree() == 0) { // Here ret was an exists node. If the father has no other son, then the father itself is false
+	// cout<<"RW work is E, father is without child"<<endl;
+	updateFalse(father);
+      }
+      // else {
+      // 	// cout<<"RW work is E, father still has children"<<endl;
+      // }
+    }
+  }
+  else { // work was not acceptable
+    for (list<QWork>::iterator j = todo.begin();j != todo.end();j++) {
+      (*j).clean();
+    }
+  }
+	
+  // cout<<"RW release"<<endl;
+  mex.release();
+}
+
+void WorkManager::updateTrue(Strategy s) { //called when s has a son who is a complete strategy
+  // cout<<"  UT on ";
+  // vector<int> hihi = s.getPosition();
+  // if (hihi.empty()) cout<<"empty";
+  // for (int i=0;i< hihi.size();i++) cout<<hihi[i]<<" ";
+  // cout<<endl;
+	
+	
+  if (s.isComplete()) {
+    // cout<<"  UT Complete ";
+    if (s.quantifier()) {
+      // cout<< " A ";
+      if (s.hasFather()) {
+	// cout<<" with father"<<endl;
+	updateTrue(s.getFather());
+      }
+      else {
+	// cout<<" without father"<<endl;
+      }
+    }
+    else {
+      // cout<<" E ";
+      if (s.hasFather()) {
+	// cout<<" with father"<<endl;
+	Strategy father = s.getFather();
+	while (father.degree() != 0) {
+	  father.detach(father.degree()-1);
+	}
+	father.attach(s);
+	trashWorks(father.getPosition());
+	updateTrue(father);
+      }
+      else {
+	// cout<<" without father"<<endl;
+				
+      }
+    }
+  }
+  else {
+    // cout<<"  UT incomplete"<<endl;
+  }
+}
+
+void WorkManager::updateFalse(Strategy s) { // called when s is false
+  // cout<<"  UF on ";
+  // vector<int> hihi = s.getPosition();
+  // if (hihi.empty()) cout<<"empty";
+  // for (int i=0;i< hihi.size();i++) cout<<hihi[i]<<" ";
+  // cout<<endl;
+	
+  trashWorks(s.getPosition());
+  if (s.isDummy()) {
+    return;
+  }
+  Strategy father=s.getFather();
+	
+  if (s.quantifier()) { // if s is universal, its father is false
+    // cout<<"  UF A";
+    if (father.isDummy()) { // if father is dummy, it is the root of the strategy. We must cut all its children and ad a false node.
+      // cout<<" father root "<<endl;
+      while (father.degree() != 0) {
+	father.detach(father.degree()-1);
+      }
+      father.attach(Strategy::SFalse());
+    }
+    // cout<<endl;
+    updateFalse(s.getFather());
+  }
+  else { // if s is existential, it it detached from its father
+    // cout<<"  UF E ";
+    father.detach(s);
+    if (father.degree() == 0) {
+      // cout<<" father false"<<endl;
+      updateFalse(father);
+    }
+    else {
+      // cout<<" father still not false"<<endl;
+    }
+  }
+}
+
+
+void WorkManager::trashWorks(vector<int> prefix) {
+  // cout<<"    TW called on ";
+  // if (prefix.empty()) cout<<"empty";
+  // for (int i=0;i< prefix.size();i++) cout<<prefix[i]<<" ";
+  // cout<<endl;
+	
+  Todos.trash(prefix);
+  for (list<AQWorker*>::iterator i=actives.begin();i!=actives.end();i++) {
+    if (isPrefix(prefix,(*i)->workPosition())) {
+      // cout<<"    TW stopping worker on";
+      // vector<int> plop = (*i)->workPosition();
+      // if (plop.empty()) cout<<"empty";
+      // for (int j=0;j< plop.size();j++) cout<<plop[j]<<" ";
+      // cout<<endl;
+      (*i)->stopAndForget();
+      i=actives.erase(i);
+      i--;
+    }
+  }
+}
+
+void WorkManager::printStatus() {
+  mex.acquire();
+  cout<<(finished?"Problem solved":"Problem not solved")<<endl;
+  cout<<"Size of pool : "<<Todos.size()<<endl;
+  cout<<"# idles : "<<idles.size()<<endl;
+  cout<<"# actives : "<<actives.size()<<endl;
+  mex.release();
+}