Learning Restricted Regular Expressions with Interleaving

TL;DR

This paper introduces a new subclass of regular expressions with interleaving for Relax NG schemas, along with a polynomial inference algorithm, demonstrating improved practicality and precision through extensive experiments.

Contribution

It proposes a novel subclass of regular expressions with interleaving and a polynomial inference algorithm for Relax NG schemas.

Findings

The new subclass outperforms previous ones in practicality.

Inferred regular expressions are more precise.

Experimental results on large-scale data validate effectiveness.

Abstract

The advantages for the presence of an XML schema for XML documents are numerous. However, many XML documents in practice are not accompanied by a schema or by a valid schema. Relax NG is a popular and powerful schema language, which supports the unconstrained interleaving operator. Focusing on the inference of Relax NG, we propose a new subclass of regular expressions with interleaving and design a polynomial inference algorithm. Then we conducted a series of experiments based on large-scale real data and on three XML data corpora, and experimental results show that our subclass has a better practicality than previous ones, and the regular expressions inferred by our algorithm are more precise.

Figures

Tables

Table 1. Table 1: The Learning Results of Different Algorithms

Learning Method	Learning Result	LS	datacost
$learne{r}_{DME}^{+}$		$1.71\ast {10}^8$	$108.67$
conMiner		$1.79\ast {10}^5$	$92.45$
InferISIRE		$4.86\ast {10}^3$	$85.66$

Table 2. Table 6: Results of Inference Using Different Methods on XML datasets

Dataset	Result of InstanceToSchema
Name	Result of learner${}_{DME}{}^{}{}_{}{}^{+}$
Sample	Result of conMiner
Size	Result of InferISIRE
NASA
2435
table(DocBook)
1719728
www(DBLP)
2000226
phdthesis(DBLP)
63420

Full text

1 Introduction

As a main file format for data exchange, the eXtensible Markup Language (XML) has been widely used on the Web [2]. XML schemas define the structure constraints of XML documents. The advantages by the presence of an XML schema for XML documents are numerous, such as for data processing, automatic data integration, static analysis of transformations and so on [4, 11, 24, 27, 28, 29, 32]. However, many XML documents are not accompanied by a (valid) schema in practice. Research in 2013 showed that only $24.8\%$ XML documents available on the Web were accompanied with corresponding schemas, of which the proportion of valid ones was only $8.9\%$ [21]. Therefore, it has become an urgent problem to infer a suitable XML schema for given XML documents.

Document Type Definition (DTD), XML Schema Definition (XSD) and Relax NG are three popular XML schema languages. Among them Relax NG is more powerful than both DTD and XSD due to its expressive power [31]. Relax NG schemas support the interleaving operator and allow the interleaving to be mixed with other operators, which can make the schemas succinct. Furthermore, the interleaving has been used in many applications. For example, it is used in the schema language ShEx for RDF [9, 34], and is necessary in solving many problems [26, 14, 23]. On the other hand, presently researches on interleaving are quite insufficient (for instance, see below). Therefore we concentrate on the study of interleaving, and focus on the inference of Relax NG in this paper. Notice that the results can also be applied to some other applications.

Actually, the major task of schema inference can be reduced to learning regular expressions from a set of given samples [5, 7, 17]. Gold proposed a classical language learning model (learning in the limit or explanatory learning) and pointed out that the class of regular expressions could not be identifiable from positive samples only [20]. Therefore, researches have focused on learning restricted subclasses of regular expressions [30].

For the inference of regular expressions, Bex et al. proposed two subclasses: single occurrence regular expressions (SOREs) and chain regular expressions (CHAREs), and gave their inference algorithms RWR and CRX [5, 6]. Freydenberger et al. gave two more efficient algorithms Soa2Sore and Soa2Chare for the above classes. Kim et al. developed an inference system using hedge grammars for learning Relax NG [22]. However, all of the above work are based on standard regular expressions, which do not support interleaving. Nevertheless, interleaving is vital since there may be no order constraint among siblings in data-centric applications [1], and it has been proved that regular expressions with interleaving are double exponentially more succinct than standard regular expressions [18].

With regard to the regular expressions with interleaving, Ghelli et al. proposed a restricted subclass called “conflict-free REs” supporting interleaving [19], where the subclass requires no symbol appears twice and repetition is only applied to single symbols, and no inference algorithm is provided. Ciucanu and Staworko proposed two subclasses called disjunctive multiplicity expressions (DME) and disjunction-free multiplicity expressions (ME) [8], which support unordered concatenation (a weaker form of interleaving), and disallow concatenation within siblings. The inference algorithm of DME is discussed in [12]. Peng et al. [33] proposed a subclass called the subset of regular expressions with interleaving (SIREs), and gave its inference algorithm based on the maximum independent set.

In this paper, to address the problem of inferencing Relax NG, we propose a restricted subclass of regular expressions with interleaving, named as Improved Subclass of Regular Expressions with Interleaving (ISIREs), and SIREs is a subclass of ISIREs. We also develop its learning algorithm. The main contributions of this paper are listed as follows.

• •

We propose a new subclass of regular expressions supporting interleaving, which helps the inference of RELAX NGs.

• •

We develop an inference algorithm InferISIRE to infer ISIREs and analyze its time complexity.

• •

We calculate the usage proportion of ISIREs and other popular subclasses based on the large-scale real data, and find that the proportion of ISIREs is the highest, which indicates ISIREs have a better practicality. Then, based on three XML data corpora, we compare the inferred results of InferISIRE with other inference algorithms. Experimental results show that the regular expressions inferred by InferISIRE are more precise.

The rest of this paper is organized as follows. Section $2$ presents the basic definitions. Section $3$ gives the inference algorithm InferISIRE. Section $4$ introduces the experiments. Conclusions are drawn in Section $5$.

2 Preliminaries

Definition 1

Regular Expression with Interleaving. Let $\Sigma$ be a finite alphabet. A string is a finite sequence of symbols over $\Sigma$. The set of all finite strings over $\Sigma$ is denoted by $\Sigma^{*}$. The empty string is denoted by $\varepsilon$. A regular expression with interleaving over $\Sigma$ is defined inductively as follows: $\varepsilon$ or $a\in\Sigma$ is a regular expression, for regular expressions $E_{1}$ and $E_{2}$, the disjunction $E_{1}|E_{2}$, the concatenation $E_{1}\cdot E_{2}$, the interleaving $E_{1}\&E_{2}$, or the Kleene-Star $E_{1}^{*}$ is also a regular expression. Usually we use $E_{1}E_{2}$ instead of $E_{1}\cdot E_{2}$ for readability. The length of a regular expression $E$, denoted by $|E|$, is the total number of alphabet symbols and operators occurring in $E$. The language generated by E is defined as follows: $L(\emptyset)=\emptyset$; $L(\varepsilon)=\{\varepsilon\}$; $L(a)=\{a\}$; $L(E_{1}^{*})=L(E)^{*}$; $L(E_{1}E_{2})=L(E_{1})L(E_{2})$; $L(E_{1}|E_{2})=L(E_{1})\cup L(E_{2})$; $L(E_{1}\&E_{2})=L(E_{1})\&L(E_{2})$. $E^{?}$ and $E^{+}$ are used as abbreviations of $E|\varepsilon$ and $EE^{*}$, respectively.

Let $u=au_{0},v=bv_{0}$, where $a,b\in\Sigma$ and $u,u_{0},v,v_{0}\in\Sigma^{*}$. Then $u\&\varepsilon=\varepsilon\&u=\{u\}$; $u\&v=\{a(u_{0}\&v)\}\cup\{b(u\&v_{0})\}$. For example, the string set generated by $a\&bc$ is $\{abc,bac,bca\}$.

Regular expressions with interleaving, in which each symbol occurs at most once, are called ISOREs extended from SOREs [5].

Definition 2

Single Occurrence Automaton (SOA) [6] Let $\Sigma$ be a finite alphabet, and let $src$ and $snk$ be distinct symbols that do not occur in $\Sigma$. A single occurrence automaton over $\Sigma$ is a finite directed graph $G$=$(V,D)$ such that

• •

src,snk$$\in$$V, and V$$\subseteq$$\Sigma$$\cup$$\{src,snk\};

• •

$src$ has only outgoing edges, $snk$ has only incoming edges and every node v$$\in$$V lies on a path from $src$ to $snk$.

A generalized single occurrence automaton (generalized SOA) over $\Sigma$ is defined as a directed graph in which each node v$$\in$$V$$\setminus$$\{src,snk\} is an ISORE and all nodes are pairwise ISOREs.

For a given directed acyclic graph $G=(V,E)$ of an SOA, the level number of node $v$ is the longest path from $src$ denoted by $ln(v)$, and $ln(src)$ is 0 [15]. For a path $v_{1}$ to $v_{2}$ , if there exists node $v$ such that $ln(v_{1})<ln(v)$ and $ln(v)<ln(v_{2})$, then $ln(v)$ is a skip level [15].

Partial Order Relation (POR) is a binary relation which is reflexive, dissymmetric and transitive. It is a collection of ordered pairs of elements over $\Sigma$. For a string $s=s_{1}s_{2}\cdot\cdot\cdot s_{n}$, $s_{i}\prec s_{j}$ means $s_{i}$ occurs before $s_{j}$. Using $POR$, we can construct the Constraint Set ($CS$) and Non-Constraint Set ($NCS$) for a set of given samples $S$. $POR(S)$ is denoted to represent the set of all partial orders obtained from each string $s\in S$. The formula is as follows.

• •

$CS(S)=\{<a_{i},a_{j}>|<a_{i},a_{j}>$ $\in POR(S),and<a_{j},a_{i}>$ $\in POR(S)\}$;

• •

$NCS(S)=\{<a_{i},a_{j}>|<a_{i},a_{j}>$ $\in POR(S),but<a_{j},a_{i}>$ $\notin POR(S)\}$.

Definition 3

Improved Subclass of Regular Expressions with Interleaving (ISIREs) Let $\Sigma$ be a finite alphabet and a$$\in$$\Sigma, the improved subclass of regular expressions with interleaving is defined by the following grammar: $S::=TS|T$, $T::=A\&T|A$, $A::=\varepsilon|a|a^{*}|AA$.

Moreover, we require that every symbol a$$\in$$\Sigma can occur at most once in the regular expression that belongs to ISIREs.

By definition, it is obvious that ISIREs is a subclass of ISOREs and SIREs [33] is a subclass of ISIREs. For example, $E_{1}=a\&b^{*}c\&de^{?}$ is an SIRE [33] and also an ISIRE, $E_{2}=a^{?}(bc^{?}\&d^{+}e)f^{*}$ is an ISIRE but not an SIRE [33], and both $E_{1}$ and $E_{2}$ are ISOREs.

3 Learning Algorithm for ISIREs

In this section, we first introduce our learning algorithm InferISIRE, which infers an ISIRE for a set of given samples $S$. Then we analyse the time complexity of the algorithm. Finally, we show the learning process of InferISIRE through an example and compare it with other algorithms.

3.1 Algorithm Implementation and Analysis

The algorithm InferISIRE uses a number of subroutines, and we introduce some of them as follows.

• $\bullet$

cntOper($S$). $cntOper(S)$ is a function to calculate unary operator of every symbol in a set of strings $S$. The function returns a dictionary of pair $(a:opt)$, where $a$ is symbol in $S$ and $opt$ is an unary operator in $\{1,?,*,+\}$ , and the $opt$ is computed according to the occurences of $a$ in strings set $S$. For example, given the set of strings $S=\{aabd,abcd,bbcd\}$, $cntOper(s)=\{a:*;b:+;c:?;d:1\}$.

• $\bullet$

Filter($mis,consist\_tr$). For a maximum independent set (MIS) $mis$ and a non-constraint set $consist\_tr$, the function returns a subset of $consist\_tr$ consisting of the ordered pairs of elements over $mis$. That is, Filter($mis$,$consist\_tr$)

=$\{<x,y>|<x,y>$ $\in consist\_tr$, and $x\in mis,y\in mis\}$;

• $\bullet$

contract($U,SubRE$) [15]. For a nodes set $U$ and a subexpression $SubRE$, the contract on an SOA modifies SOA such that all nodes of $U$ are contracted to a single vertex and labeled $SubRE$ (corresponding edges are moved).

The pseudo-code of the inference algorithm InferISIRE is shown in Algorithm 1, which outputs an ISIRE for an input set of strings. We illustrate the main procedures of InferISIRE in the following.

Traverse the samples $S$ to get the alphabet $\Sigma$, and get the dictionary $dictOper$ with the function $cntOper(S)$. This step is shown in line 1. 2. 2.

We compute the non-constraint set $consist\_tr$ and constraint set $constraint\_tr$, and construct an undirected graph $G$ using symbols in $\Sigma$ as nodes and ordered pairs in constraint set as edges. We then get the set $subGraphs$ consisting of all maximal connected subgraph of $G$ using function $connected\_subgraph(G)$. The lines 2-4 show the process. 3. 3.

In line 6 and line 7, for each maximal connected subgraph of $G$, namely every $subgraph$ in the set $subGraphs$, we transform it to a subexpression with algorithm G2SubRE showed in Algorithm 2 (introduced later). We get the set $R$ of all subexpressions. 4. 4.

We use $2T$-$INF$ [16] to construct the SOA $\mathcal{A}$ of $S$. Transform each subexpression $SubRE$ into set of nodes with function $SubRE2Nodes(SubRE)$, then contract the SOA $\mathcal{A}$ with function contract($U,SubRE$). After this procedure we actually turn the SOA into a generalized SOA. The steps are shown in lines 9-11. 5. 5.

Finally we calculate level number for every nodes of generalized SOA and find all skip levels, if there are more than one $\&$ node (node with $\&$ operator) with the same level number, or if a level is a skip level, then ? is appended to every chain factor on that level. The lines 12-20 show the process and return an ISIRE in the end.

Here we give a brief explanation of the algorithm G2SubRE, which transforms an undirected graph to a subexpression. For an undirected graph $g$, the algorithm finds the approximation of maximum independent set (MIS) of $g$ with function $clique\_removal(g)$ [10], then adds it to list $allmis$ and deletes the MIS and their related edges from $g$. The process is repeated until there exist no nodes in $g$. For each MIS $mis$ in $allmis$, we establish a directed graph $dg$ with its filtered subset Filter($mis,consist\_tr$), then we compute the topological sort for all subgraphs of $dg$ and add the result to $T$. Finally, the algorithm returns the subexpression whose corresponding counting operators can be read from $dictOper$.

Algorithm Analysis. Let $m$ denotes the sum length of the input strings in $S$, and $n$ denotes the number of alphabet symbols. It takes $O(m+n)$ to calculate all partial orders as well as constructing a graph. For a graph $G(V,E)$ with $|V|=n$ and $|E|=m$, it costs time $O(m+n)$ to find all maximal connected subgraphs. The time complexity of $clique\_removal()$ is $O(n^{2}+m)$. Thus for each subgraphs, computation of $allmis$ costs time $O(n^{3}+m)$. Since the number of maximal connected subgraphs of a graph is finite, the computation of $allmis$ for all subgraphs also costs time $O(n^{3}+m)$. Constructing SOA for $S$ and generalizing SOA can be finished in time $O(m+n)$, and assigning level numbers and computing all skip levels will be finished in time $O(m+n)$. All nodes will be converted into specific chain factors of ISIRE in $O(n)$. Therefore, the time complexity of InferISIRE is $O(n^{3}+m)$.

3.2 A Learning Example

The Language Size. The Language Size (LS for short), which measures for the simplest deterministic expression that “best” describes sample $S$. Formally, the Language Size of regular expression is calculated as follows: $\mathcal{LS}(E)=\sum^{n}_{i=0}|L(E)^{=i}|$ where $n=2|\Sigma|+1$ and $|\Sigma|$ is the size of alphabet of expression $E$, and $|L(E)^{=i}|$ denote the number of words in language $L(E)$ of length $i$. Then the regular expression with the smaller value of $\mathcal{LS}(E)$ overgeneralizes $S$ the less.

The Minimum Description Length measure. To evaluate the preciseness of different learning algorithms, we employ the data encoding cost proposed in [3], which reflects the degree of generalization of a regular expression for a given set of samples $S$. The data encoding cost compares the size of $S$ with the size of the language defined by an inferred expression $E$, $datacost(E,S)=\sum^{n}_{i=0}(2*log_{2}i+log_{2}(^{|L^{=i}(E)|}_{|S^{=i}|}))$, where $n=2|\Sigma|+1$ as before, and ${L}^{=i}(E)$ is the subset of words in ${L}(E)$ that have length $i$. Suppose $E_{1}$ and $E_{2}$ are two generalizations of $S$. If $datacost(E_{1},S)<datacost(E_{2},S)$, then we say $E_{1}$ describes $S$ better which overgeneralizes $S$ less.

Let $S=\{aabcde,acdcfe,dbbcfe,adbcef\}$, we get $\Sigma=\{a,b,c,d,e,f\}$, $dictOper$ $=\{a:*;b:*;c:+;d:1;e:1;f:?\}$, $CS(S)=\{<c,d>,<d,c>,<b,d>,<d,b>,<f,e>,<e,f>\}$, $NCS(S)=\{<c,f>,<a,c>,<a,e>,<b,f>,<b,c>,<d,e>,<a,d>,<a,f>,<c,e>,<b,e>,<a,b>,<d,f>\}$. By recognizing alphabet symbols and $CS(S)$ we get the undirected graph $G$ showed in Fig. 4. We get three maximal connected subgraphs of $G$ using function $connected\_subgraph(G)$, namely, $G_{1}=(V_{1}=\{a\},E_{1}=\{\})$, $G_{2}=(V_{2}=\{e,f\},E_{2}=\{(e,f)\})$, $G_{3}=(V_{3}=\{b,c,d\},E_{3}=\{(b,d),(d,c)\})$, and they are shown in Fig. 4 with different colors. Then we use G2SubRE to transform $G_{1},G_{2},G_{3}$ to subexpressions $r_{1},r_{2},r_{3}$. Here we introduce the transformation process of $G_{3}$. For graph $G_{3}$, we obtain MIS set $allmis$ = $\{\{b,c\},\{d\}\}$. Next, compute the topological sort for each MIS. Filter({b,c},NCS(S))=$\{<b,c>\}$, so we add $bc$ to $T$. For $\{d\}$ there is only one node add $d$ to $T$, at last $T=\{bc,d\}$. Then using $learner_{oper}(dictOper,T)$, we concatenate all elements of $T$ with $\&$ and add unary operate for each symbol, and get the subexpression $r_{3}=b^{*}c^{+}\&d$. Simiarily $r_{1}=a^{*}$, $r_{2}=e\&f^{?}$. We construct the SOA $\mathcal{A}$ using algorithm 2T-INF [16], the SOA $\mathcal{A}$ is shown in Fig. 4. Then we contract SOA with $r_{1},r_{2},r_{3}$ and get generalized SOA presented in Fig. 4. We calculated level number for every nodes of generalized SOA and get the final inferred $result=a^{*}(b^{*}c^{+}\&d)(e\&f^{?})$.

For this sample $S$, Table. 1 shows the learning result of $learner^{+}_{DME}$ (for DME)[12], conMiner (for SIRE) [33] and InferISIRE. The learning result of $learner^{+}_{DME}$ allows all symbols to appear in any order, but in the sample $S$, from $NCS(S)$ we can get all ordered pairs of symbols, i.e., symbol $c$ always occurs before symbol $f$. Besides, in $S$, for all strings that symbol $a$ occurs, $a$ always occurs in the first position. Result of InferISIRE is consistent with this constrains while neither $learner^{+}_{DME}$ nor conMiner conform to this. Among the three algorithms, the result of InferISIRE has the smallest Language Size and $datacost$, which shows preciseness of the regular expressions inferred by InferISIRE.

4 Experiments

In this section, we first analyse the usage proportion of ISIREs and other subclasses based on large-scale real data. Then we compare our learning algorithm InferISIRE with other learning algorithms of different subclasses ($Learn_{DME}^{+}$ for DME [12], conMiner for SIRE [33])) and one XML tool (InstanceToSchema [13]). All experiments were conducted on a machine with Intel Core i5-5200U@2.20GHz, 4G memory. All codes are written in python 3.

4.1 Experiment of Practicality Analysis

We crawled 4,872 distinct Relax NG schema files from 254 websites, and 103 Github repositories utilizing Google Search Engine. We extracted 137,286 regular expressions from these files, and found that 38.45% expressions have the interleaving operator, which shows its widespread use in practice. Based on this 137,286 regular expressions, we investigated the usage proportion of ISIREs compared with other popular subclasses. The experimental result is shown in Fig.5. Note that SORE [6] and CHARE [15] are subclasses of standard regular expressions, and DME [8, 12], SIRE [33] and ISIRE are subclasses supporting &. It is obvious from Fig. 5 that ISIRE has the highest proposition. The result shows ISIREs are more practical in real-world applications.

4.2 Analysis on Learning Results of Different Algorithms

We downloaded three XML data corpora, including DBLP (computer science bibliography corpus), NASA (Datasets converted from legacy flat-file format into XML), DocBook (a schema maintained by the DocBook Technical Committee of OASIS). Based on sets of strings extracted from these corpora, we compare the learning results of InferISIRE, the XML tool InstanceToSchema [13] (i2s for short), $learner^{+}_{DME}$ [12] and conMiner [33], which all support learning a regular expression with interleaving from XML data.

We first use the Language Size and $datacost$ to measure the preciseness of expressions for a set of samples. However, during experiments on real data, we found that when the alphabet is large, the calculation of Language Size and $datacost$ becomes extraordinarily time-consuming, since it needs a lot of tedious work for computing the number of subset words of $L(E)$. Given an expression $E=a^{*}b^{?}(c^{*}\&d^{?})ef^{+}$ as an example, $n=2*6+1=13$, actually it is tough to compute the number of words in $L(E)$ with length 13. Thus we introduce a simple definition called Combinatorial Cardinality to value the precision of expressions. Combinatorial Cardinality is limited to measure the precision of expressions with interleaving, satisfying that different expressions have the same symbols with the same unary operators $\{1,?,*,+\}$. The smaller value of Combinatorial Cardinality, the more precise of an expression. It is defined as follows.

Definition 4

Combinatorial Cardinality ($CC$) [25] Let $\Sigma$ be the finite alphabet set. $E_{i}$ is a regular expression with interleaving over $\Sigma$. a,b$$\in$$\Sigma and u,u^{\prime},v,v^{\prime}$$\in$$\Sigma^{*}.

• •

$CC(a)=CC(\varepsilon)=1$, where $a\in\Sigma$;

• •

$CC(E^{t})=CC(E)$, where $t\in rep$;

• •

$CC(E_{1}|E_{2}\cdots|E_{n})=CC(E_{1})+CC(E_{2})+\cdots+CC(E_{n})$;

• •

$CC(E_{1}\cdot E_{2}\cdots E_{n})=CC(E_{1})\times CC(E_{2})\times\cdots\times CC(E_{n})$;

• •

$CC(u\&v)=CC(a\cdot(u^{\prime}\&v))+CC(b\cdot(u\&v^{\prime}))$, where $u=au^{\prime}$ and $v=bv^{\prime}$;

• •

$CC((E_{1}|E_{2}|\cdots|E_{m})\&(E_{1}^{\prime}|E_{2}^{\prime}|\cdots|E_{n}^{\prime}))=CC(\bigcup_{i=1\\ j=1}^{i=m\\ j=n}E_{i}\&E_{j}^{\prime})$.

The inferred regular expressions on these three XML corpora are shown in Table. 6. For every XML data set, the inferred regular expressions of InstanceToSchema [13], conMiner [33], $learner^{+}_{DME}$ [12] and InferISIRE are shown from top to bottom. To save space, we use the short names of words and the list of abbreviations is shown in https://github.com/yetingli/sofsem2019. We calculated the Language Size, $datacost$ and $CC$ for the inferred results of different methods on each data set, and they are presented in Table. 4.2-4.2 respectively. We find that all regular expressions inferred by InstanceToSchema are only symbols combined with the interleaving, not surprisingly, its result has a maximum Language Size, $datacost$ and $CC$ on each data set, which denotes overgeneralization of InstanceToSchema. Meanwhile, we find that the Language Size, $datacost$ and $CC$ values of regular expressions inferred by InferISIRE are the smallest on all the data sets, which indicates its better preciseness and the least generalization among these methods.

Taking the results on NASA as an example. Both InstanceToSchema and $learner^{+}_{DME}$ only use interleaving to connect all symbols, thus some sequential restrictions have been lost and learning results are overgeneralization. Furthermore, conMiner can not learn some consistent partial orders due to the limits in SIREs, that is the & operator can only appears at the outermost layer of an expression in SIRE. In the strings set extracted from nasa.xml, $a_{1}$ always occurs at the first position of strings and $a_{9}$ always occurs at the last position of strings, the result of InferISIRE conforms to this constrain. But the result of conMiner allows $a_{10}$ to appear before $a_{1}$ or after $a_{9}$, which makes the result overgeneralization for samples. To conclude, the regular expressions inferred by InferISIRE are more precise compared with other tools and methods.

5 Conclusion

In this paper, focusing on the inference of Relax NGs, we proposed a new subclass ISIREs of regular expressions with interleaving. Then we designed a polynomial inference algorithm InferISIRE to learn ISIREs. Based on large-scale real data, we calculated the usage proportion of ISIREs and other popular subclasses, and found that the proportion of ISIREs is the highest, which shows ISIREs have a better practicality. At last we compare the inferred results of InferISIRE with other inference algorithms on three XML data corpora, experimental results showed that the regular expressions inferred by InferISIRE are more precise.