Improved Methods for Computing Distances between Unordered Trees Using Integer Programming

TL;DR

This paper introduces improved integer programming formulations for computing distances between unordered trees, leveraging dynamic programming and bipartite matching, resulting in significantly enhanced computational performance.

Contribution

The authors develop new integer programming models for tree distances that are more efficient, dividing problems into smaller subproblems and reducing constraints compared to prior methods.

Findings

Significant performance improvements over previous methods

Reduced number of subproblems and constraints

Efficient polynomial-time solutions for certain distances

Abstract

Kondo et al. (DS 2014) proposed methods for computing distances between unordered rooted trees by transforming an instance of the distance computing problem into an instance of the integer programming problem. They showed that the tree edit distance, segmental distance, and bottom-up segmental distance problem can be respectively transformed into an integer program which has $O(nm)$ variables and $O(n^2m^2)$ constraints, where $n$ and $m$ are the number of nodes of input trees. In this work, we propose new integer programming formulations for these three distances and the bottom-up distance by applying dynamic programming approach. We divide the tree edit distance problem into $O(nm)$ subproblems each of which has only $O(n + m)$ constraints. For the other three distances, each subproblem can be reduced to a maximum weighted matching problem in a bipartite graph which can be solved in polynomial time. In order to evaluate our methods, we compare our method to the previous one due to Kondo et al. The experimental results show that the performance of our methods have been improved remarkably compared to that of the previous method.

Tables

Table 1. Table 1: Experimental results with Glycan for edit distance

# of nodes	# of instances	IP_Edit		DpIP_Edit		IP_DpClique_E
		avg	t.o.	avg	t.o.	avg	t.o.
50 - 54	100	2.393	0	0.308	0	0.994	0
55 - 59	100	4.661	0	0.417	0	1.576	0
60 - 64	88	11.661	6	0.576	0	2.894	0
65 - 69	36	17.774	4	0.669	0	3.433	0
70 - 74	100	13.209	7	0.654	0	11.799	7
75 - 79	29	20.771	9	0.823	0	11.411	7
80 - 84	9	18.705	8	1.094	0	14.941	6
85 - 89	5	0	5	1.330	0	21.838	3
90 - 94	4	0	4	1.442	0	0	4

Table 2. Table 2: Experimental results with Glycan for segmental distance, bottom-up segmental distance, and bottom-up distance

# of nodes	# of instances	IP_Sg		DpIP_Sg		IP_BotSg		DpIP_BotSg		IP_Bot		DpIP_Bot
		avg	t.o.	avg	t.o.	avg	t.o.	avg	t.o.	avg	t.o.	avg	t.o.
50 - 54	100	5.306	0	0.135	0	1.545	0	0.136	0	0.569	0	0.131	0
55 - 59	100	9.070	5	0.135	0	2.539	0	0.139	0	0.785	0	0.131	0
60 - 64	88	13.983	41	0.137	0	4.767	0	0.142	0	1.258	0	0.132	0
65 - 69	36	23.813	27	0.140	0	6.219	0	0.147	0	1.544	0	0.133	0
70 - 74	100	20.408	97	0.145	0	10.252	4	0.150	0	1.453	0	0.134	0
75 - 79	29	21.274	27	0.148	0	12.794	5	0.154	0	2.021	0	0.137	0
80 - 84	9	0	9	0.152	0	17.606	3	0.160	0	3.002	0	0.137	0
85 - 89	5	0	5	0.157	0	29.157	4	0.163	0	3.869	0	0.142	0
90 - 94	4	0	4	0.161	0	0	4	0.166	0	4.476	0	0.145	0

Table 3. Table 3: Experimental results with SUBLOG3 for edit distance

# of nodes	# of instances	IP_Edit		DpIP_Edit		IP_DpClique_E
		avg	t.o.	avg	t.o.	avg	t.o.
50 - 54	100	2.478	0	0.435	0	3.853	0
55 - 59	100	3.892	0	0.510	0	5.393	2
60 - 64	100	6.641	0	0.633	0	8.243	17
65 - 69	100	9.921	1	0.760	0	7.191	34
70 - 74	100	15.077	9	0.917	0	8.244	44
75 - 79	100	16.534	29	1.112	0	6.352	47
80 - 84	100	19.024	45	1.247	0	5.144	44
85 - 89	100	21.249	70	1.449	0	4.711	48
90 - 94	100	23.946	91	1.872	0	6.863	59
95 - 99	100	26.599	92	2.136	0	7.971	61

Table 4. Table 4: Experimental results with SUBLOG3 for segmental distance, bottom-up segmental distance and bottom-up distance

# of nodes	# of instances	IP_Sg		DpIP_Sg		IP_BotSg		DpIP_BotSg		IP_Bot		DpIP_Bot
		avg	t.o.	avg	t.o.	avg	t.o.	avg	t.o.	avg	t.o.	avg	t.o.
50 - 54	100	5.978	0	0.136	0	1.970	0	0.140	0	0.568	0	0.131	0
55 - 59	100	10.208	7	0.136	0	2.922	0	0.141	0	0.764	0	0.132	0
60 - 64	100	13.791	31	0.141	0	5.245	0	0.145	0	1.076	0	0.134	0
65 - 69	100	18.372	57	0.144	0	6.562	1	0.148	0	1.390	0	0.135	0
70 - 74	100	20.195	75	0.146	0	8.513	15	0.151	0	1.856	0	0.137	0
75 - 79	100	22.485	87	0.149	0	11.003	10	0.154	0	2.372	0	0.138	0
80 - 84	100	22.865	91	0.150	0	12.489	18	0.157	0	3.031	0	0.139	0
85 - 89	100	26.028	94	0.154	0	14.864	25	0.160	0	3.746	0	0.140	0
90 - 94	100	26.866	98	0.158	0	17.244	48	0.167	0	4.861	0	0.144	0
95 - 99	100	0	100	0.160	0	18.644	57	0.170	0	5.808	0	0.147	0

Table 5. Table 5: Experimental results with SUBLOG49 for edit distance

# of nodes	# of instances	IP_Edit		DpIP_Edit		IP_DpClique_E
		avg	t.o.	avg	t.o.	avg	t.o.
50 - 54	100	1.275	0	0.263	0	1.643	0
55 - 59	100	2.323	0	0.317	0	3.014	0
60 - 64	100	4.032	0	0.395	0	5.452	3
65 - 69	100	4.756	0	0.402	0	6.721	6
70 - 74	100	6.231	1	0.450	0	7.188	10
75 - 79	100	8.808	10	0.567	0	9.787	19
80 - 84	100	11.850	6	0.583	0	10.037	28
85 - 89	100	12.429	21	0.665	0	10.145	34
90 - 94	100	13.595	33	0.678	0	11.228	34
95 - 99	100	15.711	30	0.829	0	12.084	39

Table 6. Table 6: Experimental results with SUBLOG49 for segmental distance, bottom-up segmental distance and bottom-up distance

# of nodes	# of instances	IP_Sg		DpIP_Sg		IP_BotSg		DpIP_BotSg		IP_Bot		DpIP_Bot
		avg	t.o.	avg	t.o.	avg	t.o.	avg	t.o.	avg	t.o.	avg	t.o.
50 - 54	100	2.130	0	0.143	0	0.739	0	0.142	0	0.376	0	0.130	0
55 - 59	100	4.704	0	0.147	0	1.521	0	0.145	0	0.514	0	0.133	0
60 - 64	100	6.795	11	0.151	0	2.863	3	0.150	0	0.707	0	0.153	0
65 - 69	100	7.741	8	0.162	0	2.544	1	0.154	0	0.830	0	0.135	0
70 - 74	100	9.277	19	0.158	0	3.257	2	0.159	0	1.036	0	0.139	0
75 - 79	100	12.421	38	0.162	0	5.143	6	0.162	0	1.376	0	0.139	0
80 - 84	100	12.707	39	0.167	0	5.788	7	0.169	0	1.644	0	0.142	0
85 - 89	100	14.817	46	0.170	0	7.136	3	0.176	0	2.129	0	0.144	0
90 - 94	100	13.267	65	0.175	0	8.479	8	0.179	0	2.361	0	0.147	0
95 - 99	100	16.752	65	0.181	0	8.776	16	0.184	0	2.881	0	0.148	0

Equations

$$cost(M)=\sum _{(x,y)\in M}d(x,y)+\sum _{x\in T_1\setminus V(M)}d(x,\epsilon )+\sum _{y\in T_2\setminus V(M)}d(\epsilon ,y).$$

$$D_{\text{Sg}}(T_1,T_2)=\underset{M\in {\mathcal{M}}^{\text{Sg}}(T_1,T_2)}{\min }cost(M)$$

$$D_{\text{BotSg}}(T_1,T_2)=\underset{M\in {\mathcal{M}}^{\text{BotSg}}(T_1,T_2)}{\min }cost(M)$$

$$D_{\text{Bot}}(T_1,T_2)=\underset{M\in {\mathcal{M}}^{\text{Bot}}(T_1,T_2)}{\min }cost(M).$$

$$cost(M)$$

$$\sum _{y\in T_2}{m}_{x,y}\le 1$$

$$\sum _{x\in T_1}{m}_{x,y}\le 1$$

$$m_{x,y}+m_{x^{\prime },y^{\prime }}\le 1$$

$$\displaystyle\begin{array}[]{l}m_{x,y}+m_{x^{\prime},y^{\prime}}\leq m_{p(x^{\prime}),p(y^{\prime})}+1,\text{ for all }(x,y),(x^{\prime},y^{\prime})\in T_{1}\times T_{2}\text{ s.t. }x<x^{\prime}\text{ and }y<y^{\prime}.\end{array}$$

$$\displaystyle\begin{array}[]{l}\displaystyle m_{x,y}\leq\sum_{\begin{subarray}{c}x^{\prime}\in L(T_{1}(x)),\\ y^{\prime}\in L(T_{2}(y))\end{subarray}}m_{x^{\prime},y^{\prime}},\text{ for all }(x,y)\in T_{1}\times T_{2}\text{ s.t. }x\notin L(T_{1})\text{ and }y\notin L(T_{2}).\end{array}$$

$$\text{minimize}\sum _{(x,y)\in T_1\times T_2}\{d(x,y)-d(x,\epsilon )-d(\epsilon ,y)\}{m}_{x,y}+\sum _{x\in T_1}d(x,\epsilon )+\sum _{y\in T_2}d(\epsilon ,y)$$

$$\text{maximize}\sum _{(x,y)\in T_1\times T_2}{w}_{x,y}{m}_{x,y},$$

$$\begin{array}[]{lll}\text{maximize}\displaystyle\sum_{(x^{\prime},y^{\prime})\in(T_{1}(x)-x)\times(T_{2}(y)-y)}w_{x^{\prime},y^{\prime}}m_{x^{\prime},y^{\prime}}+w_{x,y}.\end{array}$$

$$\sum _{(x^{\prime },y^{\prime })\in M}{W}_{x^{\prime },y^{\prime }}{m}_{x^{\prime },y^{\prime }}+w_{x,y}$$

$$\displaystyle\begin{array}[]{l}m_{x^{\prime},y^{\prime}}+m_{x^{\prime\prime},y^{\prime\prime}}\leq 1\text{ for all }(x^{\prime},y^{\prime}),(x^{\prime\prime},y^{\prime\prime})\in T_{1}(x)\times T(y)\text{ s.t. }x^{\prime}<x^{\prime\prime}\text{ or }y^{\prime}<y^{\prime\prime}.\end{array}$$

$$\begin{array}[]{ll}\displaystyle\sum_{x^{\prime}\in P^{T_{1}}_{xl}-x}\sum_{y^{\prime}\in T_{2}(y)}m_{x^{\prime},y^{\prime}}\leq 1&\text{ for all }l\in L(T_{1}(x)),\\ \displaystyle\sum_{y^{\prime}\in P^{T_{2}}_{yl}-y}\sum_{x^{\prime}\in T_{1}(x)}m_{x^{\prime},y^{\prime}}\leq 1&\text{ for all }l\in L(T_{2}(y)).\end{array}$$

$$\displaystyle\begin{array}[]{lll}\text{maximize}&\displaystyle\sum_{x^{\prime}\in T_{1}(x)-x,y^{\prime}\in T_{2}(y)-y}W_{x^{\prime},y^{\prime}}m_{x^{\prime},y^{\prime}}+w_{x,y}&\\ \text{subject to}&\displaystyle\sum_{x^{\prime}\in P^{T_{1}}_{xl}-x}\sum_{y^{\prime}\in T_{2}(y)-y}m_{x^{\prime},y^{\prime}}\leq 1&\text{ for all }l\in L(T_{1}(x))\\ &\displaystyle\sum_{y^{\prime}\in P^{T_{2}}_{yl}-y}\sum_{x^{\prime}\in T_{1}(x)}m_{x^{\prime},y^{\prime}}\leq 1&\text{ for all }l\in L(T_{2}(y))\\ &m_{x^{\prime},y^{\prime}}\in\{0,1\}&\text{ for all }x^{\prime}\in T_{1}(x)-x,y^{\prime}\in T_{2}(y)-y.\end{array}$$

$$\displaystyle\begin{array}[]{lll}\text{maximize}&\displaystyle\sum_{x\in T_{1},y\in T_{2}}W_{x,y}m_{x,y}&\\ \text{subject to}&\displaystyle\sum_{x\in P^{T_{1}}_{r(T_{1})l}}\sum_{y\in T_{2}}m_{x,y}\leq 1&\text{ for all }l\in L(T_{1})\\ &\displaystyle\sum_{y\in P^{T_{2}}_{r(T_{2})l}}\sum_{x\in T_{1}}m_{x,y}\leq 1&\text{ for all }l\in L(T_{2})\\ &m_{x,y}\in\{0,1\}&\text{ for all }x\in T_{1},y\in T_{2}.\end{array}$$

$$\displaystyle\begin{array}[]{l}\displaystyle m_{x,y}\leq\sum_{y^{\prime}\in C(y)}m_{x^{\prime},y^{\prime}}\text{ for all }(x,y)\in T_{1}\times T_{2}\text{ and for all }x^{\prime}\in C(x),\\ \displaystyle m_{x,y}\leq\sum_{x^{\prime}\in C(x)}m_{x^{\prime},y^{\prime}}\text{ for all }(x,y)\in T_{1}\times T_{2}\text{ and for all }y^{\prime}\in C(y).\end{array}$$

$$d(x,y)=\left\{\begin{array}[]{ll}0&\text{ if }l_{1}(x)=l_{2}(y)\\ 1&\text{ otherwise }\end{array}\right..$$

Full text

1 Introduction

In machine learning applications, it is important to compare (dis)similarities between tree-structured data such as XML and RNA secondary structures. There are many measures of similarities between two trees. The tree edit distance [16] is one of the most widely used measures, which is defined as the minimum cost of edit operations to transform a tree into another. It is equivalent to finding the maximum cost of a Tai mapping between two trees. However, the tree edit distance may not be appropriate to use in some applications where structure-sensitivity is required. In this context, many variants of Tai mapping have been proposed (see [12], for example). In this study, four measures are covered including the edit distance, segmental distance [9], bottom-up segmental distance [9] and bottom-up distance [17].

It is known that most of distances between ordered rooted trees can be computed in polynomial time. For example, Tai [16] showed that the tree edit distance between ordered rooted trees can be computed in $O(n^{3}m^{3})$ time, where $n$ and $m$ are the number of nodes of input trees, and Demaine et al. [4] improved the running time to $O(nm^{2}(1+\log\frac{n}{m}))$. However, if input trees are unordered, the problems of computing the above four distances are known to be not only NP-hard [20], but also MAX SNP-hard [9, 17, 19]. Akutsu et al. studied the tree edit distance problem between unordered trees from a theoretical algorithmic perspective. They gave an approximation algorithm and exact algorithms [1, 2, 3]. From the practical point of view, many researches have been done so far. Horesh et al. [7] proposed an A∗ algorithm to solve this problem for unlabeled unordered trees and Higuchi et al. [6] extended it for labeled trees. Fukagawa et al. [5] proposed a method to reduce the edit distance problem into the maximum vertex weighted clique problem which can be solved by an algorithm due to [15]. They showed that the clique-based method is as fast as A*-based method. Mori et al. [14] improved it by applying a dynamic programming approach. They showed that their method is faster than the previous clique-based method. Kondo et al. [11] proposed a method to reduce an instance of the edit distance problem into an instance of integer linear programming (IP) problem with $O(nm)$ variables and $O(n^{2}m^{2})$ constraints, where $n$ and $m$ are the number of nodes of input trees, respectively. However, the instance of their IP formulation has a large number of constraints and hence their method may not be applicable to moderate-sized instances. Although they showed that their method is faster than the clique-based method of Mori et al. [14] when input trees have large degree nodes, their IP-based method is not very effective when input trees have no large degree nodes or the size of tree is large.

An advantage of IP-based method is that we can easily make an IP formulation representing variations of the edit distance by adding some additional constraints. In fact, Kondo et al. showed IP formulations which represent segmental distance and bottom-up segmental distance by adding appropriate constraints. Another advantage of this method is that we can use state-of-the-art IP solvers (e.g. Gurobi, CPLEX), which can quickly solve many hard problems.

In this paper, we propose improved methods to compute the edit distance, segmental distance, bottom-up segmental distance and bottom-up distance between unordered rooted trees. The improvement of computational efficiency is obtained by applying a dynamic programming approach due to [14]. However, it is not only sufficient to apply the dynamic programming but it is necessary to use a structural property of rooted trees. Their dynamic programming with this property allows us to drastically reduce the number of constraints in our IP formulations for the above distances. For the edit distance problem, our method has to solve $O(nm)$ subproblems each of which has only $O(n+m)$ constraints. For the other distances, each subproblem except the problem of combining the solutions of subproblems can be reduced to the maximum weighted matching problem in a bipartite graph, which can be solved in polynomial time using the Hungarian method [13].

The rest of the paper is organized as follows. We give notations and preliminary results in Sect. 2 and briefly explain the previous method in Sect. 3. In Sect. 4, we introduce our new methods. In order to evaluate our methods, we implemented previous and our methods and conducted experiment using Glycan dataset [10] and CSLOGS dataset [18]. The results of our experiments are shown in Sect. 5. Finally, we conclude our paper with some discussions.

2 Preliminaries

Let $T$ be a rooted tree. The root of $T$ is denoted by $r(T)$. In this paper, we simply write $T$ to represent the set of nodes of $T$. For $x,y\in T$, $x\leq y$ means that $x$ is on the unique path between the root and $y$. If $x\leq y$ and $x\neq y$, we write $x<y$ and say that $x$ is an ancestor of $y$ and $y$ is a descendant of $x$. It is easy to see that the relation $\leq$ is a partial order on $T$. A parent of $x$, denoted by $p(x)$, is the closest ancestor of $x$. The children of $x$, denoted by $C(x)$, is the set of the closest nodes to $x$ among the all descendants of $x$. We call the number of children of $x$ the degree of $x$. A node $x$ is called a leaf if it has no children. The set of all leaves of a tree $T$ is denoted by $L(T)$. Nodes $x$ and $y$ are siblings if they has the same parent. A tree is called unordered tree if there is no order between siblings. Let $\Sigma$ be a finite alphabet and $l_{T}:T\rightarrow\Sigma$ a labeling function. A tuple $(T,l_{T})$ is called a labeled tree. For $x\in T$, we use $T(x)$ to denote the subtree of $T$ rooted at $x$. For notational convenience, we simply write $T-x$ to denote the subgraph of $T$ obtained by removing a node $x$.

2.1 Tree Edit Distance

The tree edit distance between two trees is defined as the minimum cost of edit operations to transform a tree into another.

Definition 1** (Edit Operations).**

Let T be a tree. Edit operations on T consist of the following three operations.

Substitution

Replace the label of a node in $T$ with a new label.

Deletion

Delete a non-root node $t$ of $T$, making all children of $t$ be the children of $par(t)$.

Insertion

Insert a new node $t$ as a child of some node $v$ in $T$, making some children of $v$ be the children of $t$.

Let $\Sigma_{\varepsilon}=\Sigma\cup\{\varepsilon\}$, where $\varepsilon$ is a blank symbol not in $\Sigma$. In order to describe costs on edit operations, we denote each of the edit operations by a pair in $\Sigma_{\varepsilon}\times\Sigma_{\varepsilon}\setminus\{(\varepsilon,\varepsilon)\}$. Substituting a node labeled with $a$ by another node labeled with $b$ is denoted by $(a,b)$. Inserting a node labeled with $b$ is denoted by $(\varepsilon,b)$. Deleting a node labeled with $a$ is denoted by $(a,\varepsilon)$. Let $d:\Sigma_{\varepsilon}\times\Sigma_{\varepsilon}\setminus\{(\varepsilon,\varepsilon)\}\rightarrow\mathbb{R^{+}}$ be a cost function on edit operations and assume, in this paper, that $d$ is a metric. In the following, we simply write $d(x,y)$ for $(x,y)\in S\times T$ to represent $d(l_{1}(x),l_{2}(y))$, where $l_{1}$ and $l_{2}$ are labeling functions on two trees $T_{1}$ and $T_{2}$, respectively.

Let $E=\langle e_{1},e_{2},\ldots,e_{t}\rangle$ be a sequence of edit operations, where $e_{i}=(a_{i},b_{i})$ for $a_{i},b_{i}\in\Sigma_{\varepsilon}$. The cost of the sequence is defined as $cost(E)=\sum_{1\leq i\leq t}d(e_{i})$.

Definition 2** (Tree Edit Distance [16]).**

Let $T_{1}$ and $T_{2}$ be trees and $\mathcal{E}(T_{1},T_{2})$ be the set of all sequences of edit operations which transform $T_{1}$ into $T_{2}$. The tree edit distance between $T_{1}$ and $T_{2}$, denoted by ${D_{\text{Edit}}}(T_{1},T_{2})$, is defined as ${D_{\text{Edit}}}(T_{1},T_{2})=\min_{E\in\mathcal{E}(T_{1},T_{2})}cost(E)$

A mapping between $T_{1}$ and $T_{2}$ is a subset of $T_{1}\times T_{2}$. The set of nodes that belongs to a mapping $M$ is denoted by $V(M)$. Tai [16] gave a combinatorial characterization of the tree edit distance by means of a mapping, which is called a Tai mapping.

Definition 3** (Tai Mapping [16]).**

Let $T_{1}$ and $T_{2}$ be trees. A mapping $M$ is called a Tai mapping if it satisfies the following constraints for every $(x,y),(x^{\prime},y^{\prime})$ in $M$:

**One-to-one correspondence : **

$x=x^{\prime}\Leftrightarrow y=y^{\prime}$,

**Preserving ancestor-descendant relationship: **

$x<x^{\prime}\Leftrightarrow y<y^{\prime}$.

The cost of a Tai mapping $M$ is defined as

[TABLE]

Let ${\mathcal{M}^{\text{Tai}}}(T_{1},T_{2})$ be the set of all Tai mappings between $T_{1}$ and $T_{2}$. Tai [16] showed the following theorem.

Theorem 1** ([16]).**

For two trees $T_{1}$ and $T_{2}$, $\displaystyle{D_{\text{Edit}}}(T_{1},T_{2})=\min_{M\in{\mathcal{M}^{\text{Tai}}}(T_{1},T_{2})}cost(M)$.

2.2 Variants of Edit Distance

The tree edit distance is one of the most widely used to measure a similarity between two trees. However, it may not be appropriate for some applications because one may need a distance on which some specific structure of trees is reflected. Many variants of the tree edit distance have been proposed in the literature [9, 17]. We work on the following three variants, which are defined by mappings rather than edit operations.

Definition 4** (Segmental Mapping [9]).**

Let $T_{1}$ and $T_{2}$ be trees. A Tai mapping $M$ between $T_{1}$ and $T_{2}$ is called a segmental mapping if for any $(x,y),(x^{\prime},y^{\prime})\in M$ with $x<x^{\prime}$ and $y<y^{\prime}$, $(p(x^{\prime}),p(y^{\prime}))\in M$.

Definition 5** (Bottom-up Segmental Mapping [9]).**

Let $T_{1}$ and $T_{2}$ be trees. A segmental mapping $M$ between $T_{1}$ and $T_{2}$ is called a bottom-up segmental mapping if for any $(x,y)\in M$, there is $(x^{\prime},y^{\prime})\in M$ such that $x^{\prime},y^{\prime}$ are leaves with $x\leq x^{\prime}$ and $y\leq y^{\prime}$.

Definition 6** (Bottom-up Mapping [17]).**

Let $T_{1}$ and $T_{2}$ be trees. A Tai mapping $M$ between $T_{1}$ and $T_{2}$ is called a bottom-up mapping if for any $(x,y)\in M$, the submapping obtained from $M$ by restricting to $C(x)\times C(y)$ forms a bijection between $C(x)$ and $C(y)$.

Let us note that the condition in Definition 6 can be restated in the following way: M is a bottom-up mapping if for any $(x,y)\in M$, the submapping obtained from $M$ by restricting to $T_{1}(x)\times T_{2}(y)$ is an isomorphism mapping, ignoring the label information.

Definition 7** ([9, 17]).**

Let $T_{1}$ and $T_{2}$ trees. Denote the sets of all possible segmental mappings, bottom-up segmental mappings, and bottom-up mappings between $T_{1}$ and $T_{2}$ by ${\mathcal{M}^{\text{Sg}}}(T_{1},T_{2}),{\mathcal{M}^{\text{BotSg}}}(T_{1},T_{2})$, and ${\mathcal{M}^{\text{Bot}}}(T_{1},T_{2})$, respectively. The segmental distance, bottom-up segmental distance, and bottom-up distance between $T_{1}$ and $T_{2}$, which are denoted by $\allowbreak{D_{\text{Sg}}}(T_{1},T_{2}),{D_{\text{BotSg}}}(T_{1},T_{2})$, and ${D_{\text{Bot}}}(T_{1},T_{2})$ respectively, are defined as follows:

[TABLE]

3 Previous Method [11]

In the rest of this paper, fix input trees $T_{1}$ and $T_{2}$, and let $n=|T_{1}|$ and $m=|T_{2}|$. Kondo et al. [11] proposed an integer linear programming formulation for the tree edit distance. For the tree edit distance between $T_{1}$ and $T_{2}$, we introduce a binary variable $m_{x,y}$ for every $(x,y)\in T_{1}\times T_{2}$ which takes value 1 if and only if $(x,y)\in{\mathcal{M}^{\text{Tai}}}(T_{1},T_{2})$. Then, we can reformulate the cost of a Tai mapping $M$ as:

[TABLE]

The two constraints of Tai mapping are directly formulated as the following inequalities:

[TABLE]

The first two constraints are equivalent to the one-to-one correspondence of Tai mapping. It means that for any node $x\in T_{1}$ (resp. $y\in T_{2}$), at most one node of $T_{2}$ (resp. $T_{1}$) is allowed to be paired. The third constraint is equivalent to the ancestor-descendant preservation. It means that for any two pairs which do not preserve the ancestor-descendant relationship, both of them cannot be included in $M$ simultaneously. This formulation contains $O(nm)$ variables and $O(n^{2}m^{2})$ constraints.

Kondo et al. also gave IP formulations for the segmental distance and bottom-up segmental distance. These distances can be formulated by imposing additional constraints on the above formulation. In regard of the segmental mapping, the constraints of segmental mapping can be represented as follows:

[TABLE]

The constraints of bottom-up segmental mapping can also be represented as follows:

[TABLE]

The above two formulations also contain $O(nm)$ variables and $O(n^{2}m^{2})$ constraints.

4 Improved Method

4.1 Improved Method for Tree Edit Distance

In this section, we propose a new IP formulation for the edit distance problem by combining a dynamic programming approach due to [14]. The dynamic programming computes a minimum cost Tai mapping $M_{x,y}$ between $T_{1}(x)$ and $T_{2}(y)$ with $(x,y)\in M_{x,y}$ for $(x,y)\in T_{1}\times T_{2}$ in a bottom-up manner. Once we have the solutions for all pairs $(x,y)\in T_{1}\times T_{2}$, we can construct a minimum cost Tai mapping between $T_{1}$ and $T_{2}$.

First, we modify the objective function

[TABLE]

to

[TABLE]

where $w_{x,y}=d(x,\varepsilon)+d(\varepsilon,y)-d(x,y)$. This modification is valid since the second and third terms do not affect the minimization.

Since the solution of our subproblem for $T_{1}(x)$ and $T_{2}(y)$ must contain the root pair $(x,y)$, the objective function on the input trees $T_{1}(x)$ and $T_{2}(y)$ can be represented as

[TABLE]

We denote by $W_{x,y}$ the maximum value of (3). If at least one of $x$ and $y$ is a leaf, $W_{x,y}=w_{x,y}$. Thus, in the following, we assume that neither $x$ nor $y$ is a leaf. The idea for our dynamic programming is that $W_{x,y}$ can be recursively computed from the values $W_{x^{\prime},y^{\prime}}$ for $x<x^{\prime}$ and $y<y^{\prime}$. To be precise, let ${\mathcal{M}}^{*}(T_{1}(x),T_{2}(y))$ be the set of all Tai mappings $M$ between $T_{1}(x)$ and $T_{2}(y)$ such that $(x,y)\notin M$ and both $T_{1}\cap V(M)$ and $T_{2}\cap V(M)$ are antichains in $(T_{1}(x),\leq)$ and $(T_{2}(y),\leq)$, respectively. For a Tai mapping $M$, we let $w(M)$ and $W(M)$ to denote $\sum_{(x,y)\in M}w_{x,y}$ and $\sum_{(x,y)\in M}W_{x,y}$, respectively. The following lemma is a key ingredient of our formulation.

Lemma 1**.**

$\displaystyle W_{x,y}=\max_{M\in{\mathcal{M}}^{*}(T_{1}(x),T_{2}(y))}W(M)+w_{x,y}$.

Proof.

We first show that the left-hand side is at most the right-hand side. Let $M$ be a Tai mapping between $T_{1}(x)$ and $T_{2}(y)$ with $(x,y)\in M$. Then, $M$ can be uniquely decomposed into $(x,y),M_{x_{1},y_{1}},M_{x_{2},y_{2}},\ldots,M_{x_{k},y_{k}}$ such that for any $1\leq i\leq k$, $M_{x_{i},y_{i}}$ is a Tai mapping between $T_{1}(x_{i})$ and $T_{2}(y_{i})$ with $(x_{i},y_{i})\in M_{x_{i},y_{i}}$ and $\bigcup_{1\leq i\leq k}(x_{i},y_{i})\in{\mathcal{M}}^{*}(T_{1}(x),T_{2}(y))$. Such a decomposition can be obtained by choosing minimal node pairs $(x_{i},y_{i})\in M\setminus\{(x,y)\}$ with respect to $\leq$: For any $(x^{\prime},y^{\prime})\in M$ either $x_{i}\leq x^{\prime}$ and $y_{i}\leq y^{\prime}$, or $x_{i}$ and $y_{i}$ are not comparable to $x^{\prime}$ and $y^{\prime}$, respectively. For each $1\leq i\leq k$, we have $w(M_{x_{i},y_{i}})\leq W_{x_{i},y_{i}}$. Therefore, $W_{x,y}\leq\sum_{1\leq i\leq k}W_{x_{i},y_{i}}+w_{x,y}=\max_{M\in{\mathcal{M}}^{*}(T_{1}(x),T_{2}(y))}W(M)+w_{x,y}$.

To show the converse, let $M^{*}\in{\mathcal{M}}^{*}(T_{1}(x),T_{2}(y))$ be maximizing the right-hand side. For each $(x^{\prime},y^{\prime})\in M^{*}$, we let $M_{x^{\prime},y^{\prime}}$ be a Tai mapping between $T_{1}(x^{\prime})$ and $T_{2}(y^{\prime})$ such that $W_{x^{\prime},y^{\prime}}=w(M_{x^{\prime},y^{\prime}})$ and $(x^{\prime},y^{\prime})\in M_{x^{\prime},y^{\prime}}$. Since $T_{1}(x)\cap V(M^{*})$ and $T_{2}(y)\cap V(M^{*})$ are antichains, $\bigcup_{(x^{\prime},y^{\prime})\in M^{*}}M_{x^{\prime},y^{\prime}}\cup\{(x,y)\}$ is a Tai mapping between $T_{1}(x)$ and $T_{2}(y)$. Therefore, we have $\max_{M\in{\mathcal{M}}^{*}(T_{1}(x),T_{2}(y))}W(M)+w_{x,y}\leq\sum_{(x^{\prime},y^{\prime})\in M^{*}}w(M_{x^{\prime},y^{\prime}})+w_{x,y}\leq W_{x,y}$ and hence the lemma holds. ∎∎

By Lemma 1, our problem is to maximize

[TABLE]

subject to $M\in{\mathcal{M}}^{*}(T_{1}(x),T_{2}(y))$.

Mori et al. [14] reduced the problem of finding a maximum weight Tai mapping in ${\mathcal{M}}^{*}(T_{1}(x),T_{2}(y))$ to the maximum vertex weight clique problem, which corresponds to the maximum weight independent set problem on complement graphs. Their reduction can be interpreted as the following constraint:

[TABLE]

However, this formulation contains $\Omega(n^{2}m^{2})$ constraints.

In order to reduce the number of constraints, we will exploit a structure of rooted trees. For a node $x\in T$ and a leaf $l\in L(T(x))$, let $P^{T}_{xl}$ be the unique path between $x$ and $l$ in $T$. Then, for any $M\in{\mathcal{M}}^{*}(T_{1}(x),T_{2}(y))$ and any $l\in L(T_{1}(x))$ (resp. $l\in L(T_{2}(y))$), at most one node of $P^{T_{1}}_{xl}$ (resp. $P^{T_{2}}_{yl}$) can be chosen in $M$, that is,

[TABLE]

This is formalized by the following lemma.

Lemma 2**.**

Let $x\in T_{1}$ and $y\in T_{2}$. Then, $W_{x,y}$ can be computed by the following IP.

[TABLE]

Proof.

By Lemma 1, it suffices to prove that $M=\{(x^{\prime},y^{\prime}):x^{\prime}\in T_{1}(x),y^{\prime}\in T_{2}(y),m_{x^{\prime},y^{\prime}}=1\}$ is in $M^{*}(T_{1}(x),T_{2}(y))$ if and only if $m_{*,*}$ is a feasible solution.

Suppose first that $M\in M^{*}(T_{1}(x),T_{2}(y))$. Since $T_{1}(x)\cap V(M)$ forms an antichain in $(T_{1},\leq)$, $M$ has at most one node in $P_{xl}^{T_{1}}$ for each $l\in L(T_{1}(x))$. Therefore, binary variables $m_{x^{\prime},y^{\prime}}$ do not violate the first type constraints. A symmetric argument for $T_{2}(y)\cap V(M)$ implies that $m_{*,*}$ is a feasible solution for the IP.

Suppose, for contradiction, $m_{*,*}$ is a feasible solution and there are $(x^{\prime},y^{\prime}),(x^{\prime\prime},y^{\prime\prime})$ in $M$ that violate the condition of $M^{*}(T_{1}(x),T_{2}(y))$. There are two possibilities: $(x^{\prime},y^{\prime})$ and $(x^{\prime\prime},y^{\prime\prime})$ violate the one-to-one correspondence of Tai mapping or at least one of $x^{\prime}<x^{\prime\prime}$ or $y^{\prime}<y^{\prime\prime}$ holds. For the former case, assume without loss of generality that $x^{\prime}=x^{\prime\prime}$ and $y^{\prime}\neq y^{\prime\prime}$. In this case, the pairs contribute at least two to a constraint for each $l\in T_{1}(x^{\prime})$, which contradict the feasibility of $m_{*,*}$. For the latter case, assume without loss of generality that $x^{\prime}<x^{\prime\prime}$. In this case, there is a path $P^{T_{1}}_{xl}-x$ that contains both $x^{\prime}$ and $x^{\prime\prime}$. The pairs contribute at least two to a constraint for such $l\in L(T_{1}(x))$ , which also contradict the feasibility of $m_{*,*}$. Therefore, the lemma holds. ∎∎

For $x\in T_{1}$ and $y\in T_{2}$, we can compute $W_{x,y}$ by using the formulation of Lemma 2. The remaining task is to compute ${D_{\text{Edit}}}(T_{1},T_{2})$ from the values $W_{x,y}$.

Theorem 2**.**

Let $opt$ be the optimal value of the following IP. Then, ${D_{\text{Edit}}}(T_{1},T_{2})=\displaystyle\sum_{x\in T_{1}}d(x,\varepsilon)+\sum_{y\in T_{2}}d(\varepsilon,y)-opt$.

[TABLE]

The proof of theorem 2 is analogous to those of Lemma 1 and 2. Our method has $O(nm)$ subproblems. Each subproblem, however, contains $O(nm)$ variables and only $O(n+m)$ constraints.

4.2 Improved Methods for Variants of Edit Distance

As the edit distance was computed in the previous section, the other distances can also be computed in the same manner: For each $x\in T_{1}$ amd $y\in T_{2}$, compute $W_{x,y}$, and then combine the solutions $W_{x,y}$ of subproblems as in Theorem 2.

4.2.1 Segmental Distance

Let $x$ and $y$ be nodes of two trees $T_{1}$ and $T_{2}$, respectively. We denote here by $W_{x,y}$ the maximum weight, that is the maximum value of (3), of segmental mappings $M_{x,y}$ between $T_{1}(x)$ and $T_{2}(y)$ with $(x,y)\in M_{x,y}$. If either $x$ or $y$ is a leaf, we have $W_{x,y}=w_{x,y}$. Thus, we suppose otherwise. Suppose $W_{x^{\prime},y^{\prime}}$ have already computed for each $(x^{\prime},y^{\prime})\in(T_{1}(x)\times T_{2}(y))\setminus\{(x,y)\}$. Observe that for any segmental mapping $M_{x,y}$ with $(x,y)\in M_{x,y}$, a child of $x$ must be paired with a child of $y$ in $M_{x,y}$. Moreover, if a descendant $x^{\prime}$ of $x$ that is not a child of $x$ is in $V(M_{x,y})$, the child of $x$ that is an ancestor of $x^{\prime}$ must be in $V(M_{x,y})$. These observations imply that $M_{x,y}$ can be constructed by a union of mappings $M_{x^{\prime},y^{\prime}}$ for $x^{\prime}\in C(x)$ and $y^{\prime}\in C(y)$, where $M_{x^{\prime},y^{\prime}}$ is a mapping between $T_{1}(x^{\prime})$ and $T_{2}(y^{\prime})$ with $(x^{\prime},y^{\prime})\in M_{x^{\prime},y^{\prime}}$. Therefore, in order to compute $W_{x,y}$, we construct a bipartite graph $G_{x,y}$ as follows. For each $z\in C(x)\cup C(y)$, we create a vertex $v_{z}$ and for each $x^{\prime}\in C(x)$ and $y^{\prime}\in C(y)$, add an edge between $v_{x^{\prime}}$ and $v_{y^{\prime}}$ whose weight equals $W_{x^{\prime},y^{\prime}}$ as in Fig. 1. It is well-known that a maximum weight bipartite matching can be solved in polynomial time using Hungarian method [13].

When $W_{x,y}$ is computed for each $x\in T_{1}$ and $y\in T_{2}$, we can compute the segmental distance between $T_{1}$ and $T_{2}$ by Theorem 2.

4.2.2 Bottom-up Segmental Distance

Because any bottom-up segmental mapping is a segmental mapping, the above observations also hold and each subproblem can be reduced to a maximum weight matching problem in a bipartite graph as well. The only difference from the case of segmental distance is that every segment must include at least one leaf. To this end, we need to exclude the following two cases from our solution. If exactly one of $x$ and $y$ is a leaf, then $W_{x,y}$ must be zero since $(x,y)$ violates the condition of bottom-up segmental mapping. The other case is that neither $x$ nor $y$ is a leaf and the solution of the maximum weight matching equals zero. This implies that an optimal mapping between $T_{1}(x)$ and $T_{2}(y)$ consists of a single pair $(x,y)$, which also violates the condition of bottom-up segmental mapping. Therefore, we set $W_{x,y}=0$ in this case.

4.2.3 Bottom-up Distance

First, we propose a naive IP formulation for computing bottom-up distance. A straightforward implication from Definition 6 is that if $(x,y)\in M$, the mapping between $C(x)$ and $C(y)$ must be a bijection. The formulation can be obtained from that of Tai mapping by adding the following constraints:

[TABLE]

This formulation contains $O(nm)$ variables and $O(n^{2}m^{2})$ constraints.

Since bottom-up mapping is a subclass of bottom-up segmental mapping, we can apply the above technique as well. All we have to do is to consider the case when two trees $T_{1}(x)$ and $T_{2}(y)$ are structurally isomorphic. Thus, for $x\in T_{1}$ and $y\in T_{2}$, we set $W_{x,y}=0$ if two subtrees $T_{1}(x)$ and $T_{2}(y)$ are not structurally isomorphic, i.e., they are isomorphic ignoring the labels.

Our improved methods contain $O(nm)$ subproblems which can be solved in polynomial time. For combining the solutions of these subproblems, we need to solve an integer program in Theorem 2. Such IPs also have $O(nm)$ variables and $O(n+m)$ constraints.

5 Experiments

To compare the experimental performance of our methods and the previous methods, we applied them to real tree-structured data. We used glycan data obtained from KEGG/Glycan database [10] and CSLOGS dataset [18] which consists of web log files. In our experiments, we adopt the unit cost for the cost function, which is defined as:

[TABLE]

We implemented the previous methods for computing edit distance (IP_Edit), segmental distance (IP_Sg), and bottom-up segmental distance (IP_BotSg) given by Kondo et al. [11] and a naive method for computing bottom-up distance (IP_Bot) described in the previous section. We also implemented our methods for computing these four distances (DpIP_Edit, DpIP_Sg, DpIP_BotSg, and DpIP_Bot). In addition to the above implementations, we intended to compare our methods with the algorithm due to Mori et al. [14]. Their algorithm reduces the tree edit distance problem to the maximum weight clique problem and uses the maximum weight clique algorithm due to [15]. However, the purpose of our experiments is to compare formulations or reductions rather than the performance of specific IP or other solvers. Therefore, we used an ordinary IP formulation of the maximum weight clique problem instead of the algorithm of [15], which is denoted by IP_DpClique_E.

We implemented the methods mentioned above in Java 1.8 combined with IBM ILOG CPLEX 12.7. We have forced CPLEX to run in sequential mode, setting parameter IloCplex.IntParam.Threads to one. Every implementation of the presented methods is also single-threaded. The experiments were performed using a computer with 3.7 GHz Quad-Core Intel Xeon E5 and 32 GB RAM, under the Mac OS X.

5.1 Glycan dataset

The results for edit distance with Glycan dataset are shown in Table 1. “# of nodes” in the table means the total number of nodes of two input trees. We randomly selected at most 100 input tree pairs from the Glycan dataset for each range of total nomber of nodes. Avg and t.o. stand for average execution time (in seconds) and the number of instances timed out, respectively. The table shows that DpIP_Edit is much faster than IP_Edit. IP_DpClique_E is not faster than IP_Edit when the size of inputs are large, while IP_DpClique_E outperforms IP_Edit when the inputs are small-sized trees. It is shown that DpIP_Edit also outperforms IP_DpClique_E. It implies that it is not sufficient to adopt a dynamic programming aproach for improving on the practical performance, and the revised IP formulation derived from the dynamic programming is of great importance for reducing the running time on the tree edit distance problem.

Table 2 shows the results for the variants of edit distance. For segmental distance and bottom-up segmental distance, the proposed methods (DpIP_Sg and DpIP_BotSg) finished computing within 1 second while the naive methods (IP_Sg and IP_BotSg) take longer than 30 seconds if the total size of input trees is large. For bottom-up distance, the naive method (IP_Bot) was fast as all instances were computed within 30 seconds. However, our improved method (DpIP_Bot) is still much faster than the naive method.

5.2 CSLOGS Dataset

We divided CSLOGS dataset into two subsets: SUBLOG3 and SUBLOG49. Every tree in SUBLOG3 (resp. SUBLOG49) is restricted to have the maximum degree at most 3 (resp. 49). We randomly selected at most 100 pairs from each dataset with a specified range of the total number of nodes.

The results of computation for SUBLOG3 are shown in Table 3 and 4. Table 5 and 6 shows the results for SUBLOG49. Compared to the results in SUBLOG3, the naive methods (IP_Edit, IP_Sg, IP_BotSg, and IP_Bot) in SUBLOG49 works faster. This property is what has been observed in the previous work by Konto et al. In regard of IP_DpClique_E, it outperforms IP_Edit when the degrees of trees are small, though their performances are scarcely different with high-degree inputs.

We can observe that the proposed methods (DpIP_Edit, DpIP_Sg, DpIP_BotSg, and DpIP_Bot) show remarkably improved the previous methods (IP_Edit, IP_Sg, IP_BotSg, and IP_Bot) as most of instances are computed within 0.2 seconds. In order to measure the scalability of the proposed methods, we used the wide range of dataset. We selected input tree pairs so that the number of total nodes ranges from around 0 to around 850. The results are shown in Fig. 2. For segmemtanl distance and bottom-up segmental distance, the smallest instance which exceeds our time limit of 30 seconds appears when the total number of nodes belongs to range 450 - 500 whereas it appears for tree edit distance when the number of nodes belongs to range 150 - 200. For bottom-up distance, all instances selected in this experiments are solved within 7 seconds.

6 Conclusion and Discussion

We have proposed improved methods for computing the tree edit distance and its variants. While the naive IP formulation proposed by Kondo et al. [11] has $O(n^{2}m^{2})$ constraints, our efficient IP formulation, though it has $O(nm)$ subproblems, only has $O(n+m)$ constraints. In case of segmental distance, bottom-up segmental distance and bottom-up distance, each subproblem, except for the problem combining the solutions of subproblems, can be reduced to the maximum weighted matching problem in a bipartite graph, which can be solved in polynomial time.

We performed some experiments using real tree-structured dataset. While the previous method only works for small-sized trees, our methods are still effective for large-sized trees. In particular, for segmental distance and bottom-up segmental distance, our methods are available for trees whose total size is up to 450, and for bottom-up distance, every instance is solved within 7 seconds.

An advantage of IP-based method is that we can easily give an IP fomulation for another distance by adding some constraints to the IP formulation for edit distance. Therefore, extending our method to another important distance measure between unordered trees such as tree alignment distance [8] would be our future work. It would be interesting to develop practical algorithms for computing those distances without using general purpose solvers such as IP solvers or SAT solvers.