submine 0.1.1__cp312-cp312-macosx_11_0_arm64.whl

submine/backends/gspan/gspan.h

@@ -0,0 +1,296 @@
+/*
+    $Id: gspan.h,v 1.6 2004/05/21 05:50:13 taku-ku Exp $;
+ 
+   Copyright (C) 2004 Taku Kudo, All rights reserved.
+     This is free software with ABSOLUTELY NO WARRANTY.
+  
+   This program is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published by
+     the Free Software Foundation; either version 2 of the License, or
+     (at your option) any later version.
+    
+   This program is distributed in the hope that it will be useful,
+     but WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+     GNU General Public License for more details.
+    
+   You should have received a copy of the GNU General Public License
+     along with this program; if not, write to the Free Software
+     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+     02111-1307, USA
+*/
+#include <iostream>
+#include <map>
+#include <vector>
+#include <set>
+#include <algorithm>
+#include <functional>
+
+// Standalone C++ build: no MATLAB/MEX dependency.
+
+namespace GSPAN {
+
+template <class T> inline void _swap (T &x, T &y) { T z = x; x = y; y = z; }
+
+struct Edge {
+	int from;
+	int to;
+	int elabel;
+	unsigned int id;
+	Edge(): from(0), to(0), elabel(0), id(0) {};
+};
+
+class Vertex
+{
+public:
+	typedef std::vector<Edge>::iterator edge_iterator;
+
+	int label;
+	std::vector<Edge> edge;
+
+	void push (int from, int to, int elabel)
+	{
+		edge.resize (edge.size()+1);
+		edge[edge.size()-1].from = from;
+		edge[edge.size()-1].to = to;
+		edge[edge.size()-1].elabel = elabel;
+		return;
+	}
+};
+
+class Graph: public std::vector<Vertex> {
+private:
+	unsigned int edge_size_;
+public:
+	typedef std::vector<Vertex>::iterator vertex_iterator;
+
+	Graph (bool _directed)
+	{
+		directed = _directed;
+	};
+	bool directed;
+
+	//  int y; // class label
+	unsigned int edge_size ()   { return edge_size_; }
+	unsigned int vertex_size () { return (unsigned int)size(); } // wrapper
+	void buildEdge ();
+	std::istream &read (std::istream &); // read
+	std::ostream &write (std::ostream &); // write
+	void check (void);
+
+	Graph(): edge_size_(0), directed(false) {};
+};
+
+class DFS {
+public:
+	int from;
+	int to;
+	int fromlabel;
+	int elabel;
+	int tolabel;
+	friend bool operator == (const DFS &d1, const DFS &d2)
+	{
+		return (d1.from == d2.from && d1.to == d2.to && d1.fromlabel == d2.fromlabel
+			&& d1.elabel == d2.elabel && d1.tolabel == d2.tolabel);
+	}
+	friend bool operator != (const DFS &d1, const DFS &d2) { return (! (d1 == d2)); }
+	DFS(): from(0), to(0), fromlabel(0), elabel(0), tolabel(0) {};
+};
+
+typedef std::vector<int> RMPath;
+
+struct DFSCode: public std::vector <DFS> {
+private:
+	RMPath rmpath;
+public:
+	const RMPath& buildRMPath ();
+
+	/* Convert current DFS code into a graph.
+	 */
+	bool toGraph (Graph &);
+
+	/* Clear current DFS code and build code from the given graph.
+	 */
+	void fromGraph (Graph &g);
+
+	/* Return number of nodes in the graph.
+	 */
+	unsigned int nodeCount (void);
+
+	void push (int from, int to, int fromlabel, int elabel, int tolabel)
+	{
+		resize (size() + 1);
+		DFS &d = (*this)[size()-1];
+
+		d.from = from;
+		d.to = to;
+		d.fromlabel = fromlabel;
+		d.elabel = elabel;
+		d.tolabel = tolabel;
+	}
+	void pop () { resize (size()-1); }
+	std::ostream &write (std::ostream &); // write
+};
+
+struct PDFS {
+	unsigned int id;	// ID of the original input graph
+	Edge        *edge;
+	PDFS        *prev;
+	PDFS(): id(0), edge(0), prev(0) {};
+};
+
+class History: public std::vector<Edge*> {
+private:
+	std::vector<int> edge;
+	std::vector<int> vertex;
+
+public:
+	bool hasEdge   (unsigned int id) { return (bool)edge[id]; }
+	bool hasVertex (unsigned int id) { return (bool)vertex[id]; }
+	void build     (Graph &, PDFS *);
+	History() {};
+	History (Graph& g, PDFS *p) { build (g, p); }
+
+};
+
+class Projected: public std::vector<PDFS> {
+public:
+	void push (int id, Edge *edge, PDFS *prev)
+	{
+		resize (size() + 1);
+		PDFS &d = (*this)[size()-1];
+		d.id = id; d.edge = edge; d.prev = prev;
+	}
+};
+
+/*  class FrequentSet {
+private:
+  std::vector <unsigned> frequent1;
+  std::map <unsigned, std::set<int> > frequent2;
+
+public:
+  void push (unsigned int);                 // set single item
+  void push (unsigned int, unsigned int);   // set two nodes
+  }; */
+
+typedef std::vector <Edge*> EdgeList;
+
+bool  get_forward_pure   (Graph&, Edge *,  int,    History&, EdgeList &);
+bool  get_forward_rmpath (Graph&, Edge *,  int,    History&, EdgeList &);
+bool  get_forward_root   (Graph&, Vertex&, EdgeList &);
+Edge *get_backward       (Graph&, Edge *,  Edge *, History&);
+
+class gSpan {
+public:
+
+	gSpan (void);
+
+	/* boostType: 1 for 1.5-class LPBoosting, 2 for 2-class LPBoosting
+	 */
+	void boost_setup (unsigned int _boostN, double _boostTau,
+		unsigned int _boostmax,
+		std::vector<double>& _boostY,
+		std::vector<double>& _boostWeights,
+		int boostType);
+
+	void run (std::istream &is, std::ostream &_os,
+		 unsigned int _minsup,
+		 unsigned int _maxpat_min, unsigned int _maxpat_max,
+		 bool _enc,
+		 bool _where,
+		 bool _directed);
+		 
+		using PatternCallback = std::function<void(const Graph& pattern,
+                                               unsigned int support,
+                                               const Projected* projected)>;
+				
+
+    	void set_callback(PatternCallback cb) { callback_ = std::move(cb); }
+private:
+
+	typedef std::map<int, std::map <int, std::map <int, Projected> > >           Projected_map3;
+	typedef std::map<int, std::map <int, Projected> >                            Projected_map2;
+	typedef std::map<int, Projected>                                             Projected_map1;
+	typedef std::map<int, std::map <int, std::map <int, Projected> > >::iterator Projected_iterator3;
+	typedef std::map<int, std::map <int, Projected> >::iterator                  Projected_iterator2;
+	typedef std::map<int, Projected>::iterator                                   Projected_iterator1;
+	typedef std::map<int, std::map <int, std::map <int, Projected> > >::reverse_iterator Projected_riterator3;
+
+	std::vector < Graph >       TRANS;
+	DFSCode                     DFS_CODE;
+	DFSCode                     DFS_CODE_IS_MIN;
+	Graph                       GRAPH_IS_MIN;
+
+
+
+	unsigned int ID;
+	unsigned int minsup;
+	unsigned int maxpat_min;	// lower bound on node count
+	unsigned int maxpat_max;	// upper bound on node count
+	bool where;
+	bool enc;
+	bool directed;
+	std::ostream* os;
+
+	/* Singular vertex handling stuff
+	 * [graph][vertexlabel] = count.
+	 */
+	std::map<unsigned int, std::map<unsigned int, unsigned int> > singleVertex;
+	std::map<unsigned int, unsigned int> singleVertexLabel;
+
+	/* Graph boosting variables
+	 */
+	bool boost;
+	double boostTau;	// lower bound to be a suitable pattern.
+	unsigned int boostN;	// Number of top-n graphs to collect
+	double boostWeightSum;	// \sum_{i=1}^L y_i d_i
+	int boostType;	// 1: 1.5-class, 2: 2-class LPBoosting
+	std::vector<double> boostY;	// +1/-1 labels
+	std::vector<double> boostWeights;	// sample weights
+
+	std::vector<Graph> bestGraphs;
+	std::vector<double> bestGraphsY;
+	std::vector<double> bestGraphsGain;
+	std::vector<std::map<unsigned int, unsigned int> > bestGraphsCounts;
+	unsigned int boostseen;
+	unsigned int boostmax;
+
+	/* Transparent pointers for gain function and gain bound.
+	 */
+	double (gSpan::* gain)(Projected &projected, double y);
+	double (gSpan::* gainbound)(Projected &projected);
+
+	/* Graph boosting methods
+	 */
+	double gainbound2 (Projected &projected);
+	double gainbound1d5 (Projected &projected);
+
+	double gain2 (Projected &projected, double y);
+	double gain1d5 (Projected &projected, double y);
+
+	void report_boosting (Projected &projected, unsigned int sup,
+		double gain, double yval);
+	void report_boosting_inter (Graph &g, unsigned int sup,
+		double gain, double yval, std::map<unsigned int, unsigned int>& GYcounts);
+	void report_single (Graph &g, std::map<unsigned int, unsigned int>& ncount);
+
+	bool is_min ();
+	bool project_is_min (Projected &);
+
+	std::map<unsigned int, unsigned int> support_counts (Projected &projected);
+	unsigned int support (Projected&);
+	void project         (Projected &);
+	void report         (Projected &, unsigned int);
+
+	std::istream &read (std::istream &);
+
+
+	void run_intern (void);
+	PatternCallback callback_;
+
+
+
+};
+};
+
+

submine/backends/gspan/ismin.cpp

@@ -0,0 +1,124 @@
+/*
+    $Id: ismin.cpp,v 1.5 2004/05/21 05:50:13 taku-ku Exp $;
+ 
+   Copyright (C) 2004 Taku Kudo, All rights reserved.
+     This is free software with ABSOLUTELY NO WARRANTY.
+  
+   This program is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published by
+     the Free Software Foundation; either version 2 of the License, or
+     (at your option) any later version.
+    
+   This program is distributed in the hope that it will be useful,
+     but WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+     GNU General Public License for more details.
+    
+   You should have received a copy of the GNU General Public License
+     along with this program; if not, write to the Free Software
+     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+     02111-1307, USA
+*/
+#include "gspan.h"
+
+namespace GSPAN {
+
+bool gSpan::is_min ()
+{
+	if (DFS_CODE.size() == 1)
+		return (true);
+
+	DFS_CODE.toGraph (GRAPH_IS_MIN);
+	DFS_CODE_IS_MIN.clear ();
+
+	Projected_map3 root;
+	EdgeList           edges;
+
+	for (unsigned int from = 0; from < GRAPH_IS_MIN.size() ; ++from)
+		if (get_forward_root (GRAPH_IS_MIN, GRAPH_IS_MIN[from], edges))
+			for (EdgeList::iterator it = edges.begin(); it != edges.end();  ++it)
+				root[GRAPH_IS_MIN[from].label][(*it)->elabel][GRAPH_IS_MIN[(*it)->to].label].push (0, *it, 0);
+
+	Projected_iterator3 fromlabel = root.begin();
+	Projected_iterator2 elabel    = fromlabel->second.begin();
+	Projected_iterator1 tolabel   = elabel->second.begin();
+
+	DFS_CODE_IS_MIN.push (0, 1, fromlabel->first, elabel->first, tolabel->first);
+
+	return (project_is_min (tolabel->second));
+}
+
+bool gSpan::project_is_min (Projected &projected)
+{
+	const RMPath& rmpath = DFS_CODE_IS_MIN.buildRMPath ();
+	int minlabel         = DFS_CODE_IS_MIN[0].fromlabel;
+	int maxtoc           = DFS_CODE_IS_MIN[rmpath[0]].to;
+
+	{
+		Projected_map1 root;
+		bool flg = false;
+		int newto = 0;
+
+		for (int i = rmpath.size()-1; ! flg  && i >= 1; --i) {
+			for (unsigned int n = 0; n < projected.size(); ++n) {
+				PDFS *cur = &projected[n];
+				History history (GRAPH_IS_MIN, cur);
+				Edge *e = get_backward (GRAPH_IS_MIN, history[rmpath[i]], history[rmpath[0]], history);
+				if (e) {
+					root[e->elabel].push (0, e, cur);
+					newto = DFS_CODE_IS_MIN[rmpath[i]].from;
+					flg = true;
+				}
+			}
+		}
+
+		if (flg) {
+			Projected_iterator1 elabel = root.begin();
+			DFS_CODE_IS_MIN.push (maxtoc, newto, -1, elabel->first, -1);
+			if (DFS_CODE[DFS_CODE_IS_MIN.size()-1] != DFS_CODE_IS_MIN [DFS_CODE_IS_MIN.size()-1]) return false;
+			return project_is_min (elabel->second);
+		}
+	}
+
+	{
+		bool flg = false;
+		int newfrom = 0;
+		Projected_map2 root;
+		EdgeList edges;
+
+		for (unsigned int n = 0; n < projected.size(); ++n) {
+			PDFS *cur = &projected[n];
+			History history (GRAPH_IS_MIN, cur);
+			if (get_forward_pure (GRAPH_IS_MIN, history[rmpath[0]], minlabel, history, edges)) {
+				flg = true;
+				newfrom = maxtoc;
+				for (EdgeList::iterator it = edges.begin(); it != edges.end();  ++it)
+					root[(*it)->elabel][GRAPH_IS_MIN[(*it)->to].label].push (0, *it, cur);
+			}
+		}
+
+		for (int i = 0; ! flg && i < (int)rmpath.size(); ++i) {
+			for (unsigned int n = 0; n < projected.size(); ++n) {
+				PDFS *cur = &projected[n];
+				History history (GRAPH_IS_MIN, cur);
+				if (get_forward_rmpath (GRAPH_IS_MIN, history[rmpath[i]], minlabel, history, edges)) {
+					flg = true;
+					newfrom = DFS_CODE_IS_MIN[rmpath[i]].from;
+					for (EdgeList::iterator it = edges.begin(); it != edges.end();  ++it)
+						root[(*it)->elabel][GRAPH_IS_MIN[(*it)->to].label].push (0, *it, cur);
+				}
+			}
+		}
+
+		if (flg) {
+			Projected_iterator2 elabel  = root.begin();
+			Projected_iterator1 tolabel = elabel->second.begin();
+			DFS_CODE_IS_MIN.push (newfrom, maxtoc + 1, -1, elabel->first, tolabel->first);
+			if (DFS_CODE[DFS_CODE_IS_MIN.size()-1] != DFS_CODE_IS_MIN [DFS_CODE_IS_MIN.size()-1]) return false;
+			return project_is_min (tolabel->second);
+		}
+	}
+
+	return true;
+}
+}

submine/backends/gspan/main.cpp

@@ -0,0 +1,106 @@
+#include <iostream>
+#include <string>
+#include <cstdlib>   // std::strtoul
+#include <cerrno>    // errno
+#include <climits>   // ULONG_MAX
+
+#include "gspan.h"  
+
+static void usage() {
+    std::cerr
+        << "Usage: gspan_cli [options] < input.data > output.txt\n"
+        << "Options:\n"
+        << "  -m <minsup>    Minimum support (same as -s)\n"
+        << "  -s <minsup>    Minimum support (same as -m)\n"
+        << "  -n <minnodes>  Minimum number of nodes in a pattern\n"
+        << "  -L <maxpat>    Maximum pattern size (edges) / limit (as in original)\n"
+        << "  -d             Enable encoding (same as -e)\n"
+        << "  -e             Enable encoding (same as -d)\n"
+        << "  -w             Output where (occurrences)\n"
+        << "  -D             Directed graphs\n"
+        << "  -h             Show this help\n";
+}
+
+// Strict-ish unsigned int parser with basic validation.
+static bool parse_uint(const char* s, unsigned int& out) {
+    if (!s || !*s) return false;
+    errno = 0;
+    char* end = nullptr;
+    unsigned long v = std::strtoul(s, &end, 10);
+    if (errno != 0 || end == s || *end != '\0') return false;
+    if (v > static_cast<unsigned long>(UINT_MAX)) return false;
+    out = static_cast<unsigned int>(v);
+    return true;
+}
+
+int main(int argc, char** argv) {
+    unsigned int minsup   = 1;
+    unsigned int maxpat   = 0xffffffffu;
+    unsigned int minnodes = 0;
+    bool where    = false;
+    bool enc      = false;
+    bool directed = false;
+
+    for (int i = 1; i < argc; ++i) {
+        std::string a = argv[i];
+
+        auto need_value = [&](const char* flag) -> const char* {
+            if (i + 1 >= argc) {
+                std::cerr << "Missing value after " << flag << "\n";
+                usage();
+                std::exit(-1);
+            }
+            return argv[++i];
+        };
+
+        if (a == "-h") {
+            usage();
+            return 0;
+        } else if (a == "-m" || a == "-s") {
+            unsigned int v = 0;
+            const char* s = need_value(a.c_str());
+            if (!parse_uint(s, v)) {
+                std::cerr << "Invalid value for " << a << ": " << s << "\n";
+                usage();
+                return -1;
+            }
+            minsup = v;
+        } else if (a == "-n") {
+            unsigned int v = 0;
+            const char* s = need_value("-n");
+            if (!parse_uint(s, v)) {
+                std::cerr << "Invalid value for -n: " << s << "\n";
+                usage();
+                return -1;
+            }
+            minnodes = v;
+        } else if (a == "-L") {
+            unsigned int v = 0;
+            const char* s = need_value("-L");
+            if (!parse_uint(s, v)) {
+                std::cerr << "Invalid value for -L: " << s << "\n";
+                usage();
+                return -1;
+            }
+            maxpat = v;
+        } else if (a == "-d" || a == "-e") {
+            enc = true;
+        } else if (a == "-w") {
+            where = true;
+        } else if (a == "-D") {
+            directed = true;
+        } else {
+            std::cerr << "Unknown option: " << a << "\n";
+            usage();
+            return -1;
+        }
+    }
+
+    // Optional I/O speedups (safe and portable)
+    std::ios::sync_with_stdio(false);
+    std::cin.tie(nullptr);
+
+    GSPAN::gSpan gspan;
+    gspan.run(std::cin, std::cout, minsup,minnodes, maxpat, enc, where, directed);
+    return 0;
+}

submine/backends/gspan/misc.cpp

@@ -0,0 +1,177 @@
+/*
+    $Id: misc.cpp,v 1.6 2004/05/21 05:50:13 taku-ku Exp $;
+ 
+   Copyright (C) 2004 Taku Kudo, All rights reserved.
+     This is free software with ABSOLUTELY NO WARRANTY.
+  
+   This program is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published by
+     the Free Software Foundation; either version 2 of the License, or
+     (at your option) any later version.
+    
+   This program is distributed in the hope that it will be useful,
+     but WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+     GNU General Public License for more details.
+    
+   You should have received a copy of the GNU General Public License
+     along with this program; if not, write to the Free Software
+     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+     02111-1307, USA
+*/
+#include "gspan.h"
+#include <assert.h>
+
+namespace GSPAN {
+
+const RMPath &DFSCode::buildRMPath ()
+{
+	rmpath.clear ();
+
+	int old_from = -1;
+
+	for (int i = size() - 1 ; i >= 0 ; --i) {
+		if ((*this)[i].from < (*this)[i].to && // forward
+				(rmpath.empty() || old_from == (*this)[i].to))
+		{
+			rmpath.push_back (i);
+			old_from = (*this)[i].from;
+		}
+	}
+
+	return rmpath;
+}
+
+void History::build (Graph &graph, PDFS *e)
+{
+	// first build history
+	clear ();
+	edge.clear ();
+	edge.resize (graph.edge_size());
+	vertex.clear ();
+	vertex.resize (graph.size());
+
+	if (e) {
+		push_back (e->edge);
+		edge[e->edge->id] = vertex[e->edge->from] = vertex[e->edge->to] = 1;
+
+		for (PDFS *p = e->prev ; p ; p = p->prev) {
+			push_back (p->edge);	// this line eats 8% of overall instructions(!)
+			edge[p->edge->id] = vertex[p->edge->from] = vertex[p->edge->to] = 1;
+		}
+		std::reverse (begin(), end());
+	}
+}
+
+/* get_forward_pure ()
+   e1 (from1, elabel1, to1)
+   from $B$+$i7R$,$k(B edge e2(from2, elabel2, to2) $B$rJV$9(B.
+
+   minlabel <= elabel2,
+   (elabel1 < elabel2 ||
+   (elabel == elabel2 && tolabel1 < tolabel2) $B$N>r7o$r$_$?$9(B. 
+   (elabel1, to1) $B$N$[$&$,@h$KC5:w$5$l$k$Y$-(B
+   $B$^$?(B, $B$$$^$^$G8+$?(B vertex $B$K$O@B$+$J$$(B (backward $B$N$d$/$a(B)
+*/
+bool get_forward_rmpath (Graph &graph, Edge *e, int minlabel, History& history, EdgeList &result)
+{
+	result.clear ();
+	assert (e->to >= 0 && e->to < graph.size ());
+	assert (e->from >= 0 && e->from < graph.size ());
+	int tolabel = graph[e->to].label;
+
+	for (Vertex::edge_iterator it = graph[e->from].edge.begin() ;
+		it != graph[e->from].edge.end() ; ++it)
+	{
+		int tolabel2 = graph[it->to].label;
+		if (e->to == it->to || minlabel > tolabel2 || history.hasVertex (it->to))
+			continue;
+
+		if (e->elabel < it->elabel || (e->elabel == it->elabel && tolabel <= tolabel2))
+			result.push_back (&(*it));
+	}
+
+	return (! result.empty());
+}
+
+/* get_forward_pure ()
+   e (from, elabel, to)
+   to $B$+$i7R$,$k(B edge $B$rJV$9(B
+   $B$?$@$7(B, minlabel $B$h$jBg$-$$$b$N$K$7$+$$$+$J$$(B (DFS$B$N@)Ls(B)
+   $B$^$?(B, $B$$$^$^$G8+$?(B vertex $B$K$O@B$+$J$$(B (backward $B$N$d$/$a(B)
+ */
+bool get_forward_pure (Graph &graph, Edge *e, int minlabel, History& history, EdgeList &result)
+{
+	result.clear ();
+
+	assert (e->to >= 0 && e->to < graph.size ());
+
+	/* Walk all edges leaving from vertex e->to.
+	 */
+	for (Vertex::edge_iterator it = graph[e->to].edge.begin() ;
+		it != graph[e->to].edge.end() ; ++it)
+	{
+		/* -e-> [e->to] -it-> [it->to]
+		 */
+		assert (it->to >= 0 && it->to < graph.size ());
+		if (minlabel > graph[it->to].label || history.hasVertex (it->to))
+			continue;
+
+		result.push_back (&(*it));
+	}
+
+	return (! result.empty());
+}
+
+/* graph $B$N(B vertex $B$+$i$O$($k(B edge $B$rC5$9(B
+   $B$?$@$7(B, fromlabel <= tolabel $B$N@-<A$rK~$?$9(B.
+*/
+bool get_forward_root (Graph &g, Vertex &v, EdgeList &result)
+{
+	result.clear ();
+	for (Vertex::edge_iterator it = v.edge.begin(); it != v.edge.end(); ++it) {
+		assert (it->to >= 0 && it->to < g.size ());
+		if (v.label <= g[it->to].label)
+			result.push_back (&(*it));
+	}
+
+	return (! result.empty());
+}
+
+/* get_backward (graph, e1, e2, history);
+   e1 (from1, elabel1, to1)
+   e2 (from2, elabel2, to2)
+   to2 -> from1 $B$K7R$,$k$+$I$&$+$7$i$Y$k(B.
+
+   (elabel1 < elabel2 ||
+   (elabel == elabel2 && tolabel1 < tolabel2) $B$N>r7o$r$_$?$9(B. (elabel1, to1) $B$N$[$&$,@h$KC5:w$5$l$k$Y$-(B
+ */
+Edge *get_backward (Graph &graph, Edge* e1, Edge* e2, History& history)
+{
+	if (e1 == e2)
+		return 0;
+
+	assert (e1->from >= 0 && e1->from < graph.size ());
+	assert (e1->to >= 0 && e1->to < graph.size ());
+	assert (e2->to >= 0 && e2->to < graph.size ());
+
+	for (Vertex::edge_iterator it = graph[e2->to].edge.begin() ;
+		it != graph[e2->to].edge.end() ; ++it)
+	{
+		if (history.hasEdge (it->id))
+			continue;
+
+		if ( (it->to == e1->from) &&
+			( (e1->elabel < it->elabel) ||
+				(e1->elabel == it->elabel) &&
+					(graph[e1->to].label <= graph[e2->to].label)
+			) )
+		{
+			return &(*it);
+		}
+	}
+
+	return 0;
+}
+}
+