Query Learning Algorithm for Residual Symbolic Finite Automata

TL;DR

This paper introduces a new query learning algorithm for residual symbolic finite automata (RSFAs), which combine properties of SFAs and RFAs to efficiently learn automata over large alphabets, outperforming existing methods.

Contribution

The paper presents the first efficient query learning algorithm for RSFAs, enabling more succinct automata representations and improved learning efficiency over large alphabets.

Findings

The algorithm efficiently learns RSFAs over huge alphabets.

RSFAs can be exponentially smaller than deterministic finite automata.

Learning RSFAs outperforms existing algorithms for deterministic SFAs.

Abstract

We propose a query learning algorithm for residual symbolic finite automata (RSFAs). Symbolic finite automata (SFAs) are finite automata whose transitions are labeled by predicates over a Boolean algebra, in which a big collection of characters leading the same transition may be represented by a single predicate. Residual finite automata (RFAs) are a special type of non-deterministic finite automata which can be exponentially smaller than the minimum deterministic finite automata and have a favorable property for learning algorithms. RSFAs have both properties of SFAs and RFAs and can have more succinct representation of transitions and fewer states than RFAs and deterministic SFAs accepting the same language. The implementation of our algorithm efficiently learns RSFAs over a huge alphabet and outperforms an existing learning algorithm for deterministic SFAs. The result also shows that the benefit of non-determinism in efficiency is even larger in learning SFAs than non-symbolic automata.

Figures

Tables

Table 1. Table 1: The upper bounds of EQs and MQs

		Deterministic	Residual
FA	EQ	$n$	$O\left(n^2\right)$	$O\left(n^2\right)$
	MQ	$O\left(n^2\left|\Sigma \right|+n\log m\right)$ [13, 20]	$O\left(n^{3}m\left|\Sigma \right|\right)$ [7]	$O\left(n^3\left|\Sigma \right|+n^3\log m\right)$ [Ours]
SFA	EQ	$O\left(n^3ℰ\right)$	$O\left(n^4ℰ\right)$
	MQ	$O\left(n^4ℳ+n^4ℰ\log m\right)$ [4]	$O\left(n^6\left(ℰ+ℳ\right)+n^5ℰ\log m\right)$ [Ours]

Full text

1 Introduction

Learning regular languages has been extensively studied because of its wide varieties of applications in many fields such as pattern recognition, model checking, data mining and computational linguistics [11]. Angluin [2] presented an algorithm $\textsf{L}*$ which learns the minimum deterministic finite automaton (DFA) accepting an unknown target language using membership queries (MQs) and equivalence queries (EQs). An MQ asks whether a string selected by the learner is a member of the target language or not. An EQ asks whether the learner’s hypothesis automaton accepts exactly the target language or not. If not, the learner gets a counterexample from the symmetric difference of the hypothesis and target languages. A teacher who can answer those two types of queries is called a minimally adequate teacher (MAT). A number of different learning algorithms working under the MAT model have been designed for regular languages [13, 14, 20]. These works have been found in applications such as specification generation [12, 17] and model verification [15]. Recently, the algorithm is also used to extract a DFA representing behavior of recurrent neural networks [22].

In such applications, alphabets tend to be extremely large and structured. The size of DFA representation grows linearly in the size of the alphabet and the number of queries needed to learn a language over the alphabet also grows linearly. Such difficulty can be alleviated by using symbolic finite automata (SFAs) [21]. An SFA has transitions that carry predicates over a Boolean algebra. By using an algebra and its predicates suitable for the languages to represent, we can make the representing SFA and learning processes for them more efficient. For example, the edge from $q_{\_}0$ to $q_{\_}1$ is labeled with $6,7,8,9$ in the DFA in Fig. 1(a), while the symbolic representation of it will be $\neg(X\leq 5)$ in Fig. 1(b), where $X$ is a free variable for which an input character is substituted. One of the first query learning algorithms targeting some types of SFAs has been proposed by Mens and Maler [18]. Their algorithm assumes a stronger teacher than MAT, but it works efficiently over large ordered alphabets such as $\mathbb{N}$ or $\mathbb{R}$. After that, several query learning algorithms which work under the standard MAT model have been proposed [4, 5, 10, 16]. In particular, the algorithm $\textsf{MAT}*$ given by Argyros and D’Antoni [4] is quite generic. It learns SFAs over any algebra when an efficient learning algorithm for the underlying algebra is available. For example, as there exists a learning algorithm for binary decision diagrams (BDDs) [19], SFAs whose transitions carry BDDs can be learned by the algorithm.

Another way to represent a regular language compactly is to introduce non-determinism. Denis et al. [8] have proposed residual finite automata (RFAs), which are a special kind of non-deterministic finite automata, and presented nice properties of them including the fact that an RFA can be exponentially smaller than the minimum DFA accepting the same language. Figure 1(c) shows an RFA that accepts the same language as the DFA in Figure 1(a). Bollig et al. [7] proposed an Angluin style learning algorithm $\textsf{NL}*$ for RFAs based on those nice properties and their experimental results demonstrated that $\textsf{NL}*$ needs fewer queries than $\textsf{L}*$ in practice.

In this paper, we propose a learning algorithm for non-deterministic SFAs, which we call residual symbolic finite automata (RSFAs) to pursue further compact representations and efficient learning. Figure 1(d) shows an example of an RSFA. The algorithm can be seen as a combination of $\textsf{MAT}*$ [4] and $\textsf{NL}*$ [7]. We prove that our algorithm learns target languages using RSFAs under the MAT model and present upper bounds on the numbers of EQs and MQs required. We also present experimental results that compare our algorithm with $\textsf{MAT}*$. We observe that the proposed algorithm asks much fewer EQs and MQs than $\textsf{MAT}*$ like Bollig et al. [7] have demonstrated for non-symbolic automata. Yet, as we will discuss in more detail in Section 5, the impact looks significantly bigger in the learning of SFAs than non-symbolic automata.

As a byproduct of our algorithm analysis, we propose an improvement for $\textsf{NL}*$ that reduces the worst case query complexity.

2 Preliminaries

2.1 Learning under Minimally Adequate Teacher

Query learning (also called active learning) is a learning model where the learner constructs a representation of an unknown target language by actively asking queries about the language. A most representative setting is learning under a minimally adequate teacher (MAT), proposed by Angluin [2]. For a target language $L_{\_}*\subseteq\Sigma^{*}$ over an alphabet $\Sigma$, a MAT answers two types of queries. The first type is a membership query (MQ), whose instance is a string $w\in\Sigma^{*}$ selected by the learner. The answer to an MQ on $w$, denoted by $\textrm{MQ}(w)$, is $\textrm{MQ}(w)=+$ if $w\in L_{\_}*$ and $\textrm{MQ}(w)=-$ otherwise. The second type is an equivalence query (EQ), whose instance is a hypothesis $\mathcal{H}$ that represents a language $L(\mathcal{H})$. The answer to an EQ is “yes” if the language $L(\mathcal{H})$ is equal to the target language $L_{\_}*$. Otherwise, the answer is a counterexample from the symmetric difference $(L_{\_}*\setminus L(\mathcal{H}))\cup(L(\mathcal{H})\setminus L_{\_}*)$ arbitrarily chosen by the teacher. For convenience, we say that an algorithm learns a class $\mathcal{R}$ of representations if it finally acquires a representation in $\mathcal{R}$ that represents an arbitrary target language in $\{L(\mathcal{H})\mid\mathcal{H}\in\mathcal{R}\}$.

Angluin has proposed a polynomial time algorithm $\textsf{L}*$ for learning deterministic finite automata (DFA). Her algorithm $\textsf{L}*$ has been improved in theoretical and practical query efficiency and memory efficiency [13, 20].

2.2 Residual Finite Automata

An ($\epsilon$-free) non-deterministic finite automaton (NFA) is a quintuple $M=(\Sigma,Q,Q_{\_}0,F,\delta)$, where $\Sigma$ is a finite alphabet, $Q$ is a finite set of states, $Q_{\_}0\subseteq Q$ is the set of initial states, $F\subseteq Q$ is the set of final states, and $\delta\colon Q\times\Sigma\rightarrow 2^{Q}$ is the transition function. An NFA is called deterministic (DFA) if $|\delta(q,a)|=1$ for all $q\in Q$ and $a\in\Sigma$. The transition function $\delta$ is extended to $\hat{\delta}\colon Q\times\Sigma^{*}\rightarrow 2^{Q}$ so that $\hat{\delta}(q,\epsilon)=\{q\}$ and $\hat{\delta}(q,aw)=\bigcup_{\_}{q^{\prime}\in\delta(q,a)}\hat{\delta}(q^{\prime},w)$ for $q\in Q$, $a\in\Sigma$ and $w\in\Sigma^{*}$. We use $\delta$ to denote $\hat{\delta}$. A string $w\in\Sigma^{*}$ is accepted by $M$ if $\delta(Q_{\_}0,w)\cap F\neq\emptyset$. For each state $q\in Q$, the language accepted by $q$ is $L_{\_}q=\{w\in\Sigma^{*}\mid\delta(q,w)\cap F\neq\emptyset\}$. The language accepted by $M$ is $L(M)=\bigcup_{\_}{q\in Q_{\_}0}L_{\_}{q}$.

A language $L^{\prime}$ is a residual language of $L$ if there exists $u\in\Sigma^{*}$ such that $L^{\prime}=u^{-1}L=\{v\in\Sigma^{*}\mid uv\in L\}$. The set of residual languages of $L$ is denoted by $\mathit{Res}(L)$. A residual finite automaton (RFA) [8] is an NFA such that $L_{\_}q\in\mathit{Res}(L(M))$ for every state $q\in Q$. In other words, each state of an RFA accepts a residual language of $L(M)$. It is not necessary that every residual language of $L(M)$ must be accepted by a single state. A residual language $u^{-1}L(M)$ is the union of languages accepted by the states reached by reading $u$ from the initial states. Denis et al. [8] showed that an RFA can be exponentially smaller than the minimum DFA accepting the same language.

A language $L$ over a (possibly infinite) alphabet is called prime in a class $\mathbb{L}$ of languages if it is not equal to the union of the languages it strictly contains, i.e., $L\neq\bigcup\{\,L^{\prime}\in\mathbb{L}\mid L^{\prime}\subsetneq L\,\}$. The set of primes in $\mathbb{L}$ is denoted by $\mathit{Prm}(\mathbb{L})$. Denis et al. [8] showed that an RFA $M$ has the minimum number of states among RFAs accepting the same language if and only if $|Q|=|\mathit{Prm}(\mathit{Res}(L(M)))|$ and $L_{\_}q\in\mathit{Prm}(\mathit{Res}(L(M)))$ for each $q\in Q$. Such an RFA is called reduced, since no states can be deleted without changing its language. Each state of the reduced RFA corresponds to a unique prime residual language of $L(M)$. For a regular language $L$, the canonical RFA of $L$ is $(\Sigma,Q,Q_{\_}0,F,\delta)$ where $Q=\mathit{Prm}(\mathit{Res}(L))$, $Q_{\_}0=\{L^{\prime}\in Q\mid L^{\prime}\subseteq L\}$, $F=\{L^{\prime}\in Q\mid\epsilon\in L^{\prime}\}$ and $\delta(L_{\_}1,a)=\{L_{\_}2\in Q\mid L_{\_}2\subseteq a^{-1}L_{\_}1\}$. The canonical RFA is reduced and has saturated transitions (i.e. no transition can be added without modifying the language accepted by the RFA).

Bollig et al. [7] has proposed an algorithm $\textsf{NL}*$ for learning RFAs extending Angluin’s algorithm $\textsf{L}*$ for DFAs. It constructs (an RFA isomorphic to) the canonical RFA of the target language. The theoretical upper bound on the number of queries required by $\textsf{NL}*$ is higher than $\textsf{L}*$ for the same regular language. However, their experimental results show that $\textsf{NL}*$ practically makes fewer queries than $\textsf{L}*$ does.

2.3 Symbolic Finite Automata

Symbolic finite automata (SFAs) are finite automata which have more expressive transitions than NFAs. In an SFA, transitions carry unary predicates over an effective Boolean algebra $\mathcal{A}$ on a (typically huge or infinite) alphabet $\Sigma$. Transitions whose predicates are satisfied by the read character $a\in\Sigma$ are executed.

An effective Boolean algebra is a tuple $\mathcal{A}=(\Sigma,\varPsi,[\![\_]\!],\bot,\top,\vee,\wedge,\neg)$, where $\Sigma$ is an alphabet, $\varPsi$ is a set of unary predicates closed under the Boolean connectives, and $[\![\_]\!]\colon\varPsi\rightarrow 2^{\Sigma}$ is a denotation function such that (i) $[\![\bot]\!]=\emptyset$, (ii) $[\![\top]\!]=\Sigma$, and (iii) for all $\varphi,\psi\in\varPsi$, $[\![\varphi\vee\psi]\!]=[\![\varphi]\!]\cup[\![\psi]\!],[\![\varphi\wedge\psi]\!]=[\![\varphi]\!]\cap[\![\psi]\!]$, and $[\![\neg\varphi]\!]=\Sigma\setminus[\![\varphi]\!]$. We assume it is decidable whether $[\![\varphi]\!]=\emptyset$ for any $\varphi\in\varPsi$ and moreover there is an effective procedure to find an element of $[\![\varphi]\!]$ unless $[\![\varphi]\!]=\emptyset$.

An SFA is a quintuple $M=(\mathcal{A},Q,Q_{\_}0,F,\Delta)$, where $\mathcal{A}$ is an effective Boolean algebra, $Q$ is a finite set of states, $Q_{\_}0\subseteq Q$ is the set of initial states, $F\subseteq Q$ is the set of final states, $\Delta\subseteq Q\times\varPsi\times Q$ is the finite transition relation. When the transition edge from $q$ to $q^{\prime}$ has a predicate label $\varphi$, i.e., $(q,\varphi,q^{\prime})\in\Delta$, this means that the transition is executed when $\varphi$ is satisfied by the reading character. That is, $\Delta$ induces the transition function $\delta\colon Q\times\Sigma\rightarrow 2^{Q}$ such that $\delta(q,a)=\{q^{\prime}\in Q\mid(q,\varphi,q^{\prime})\in\Delta,\,a\in[\![\varphi]\!]\}$ for $q\in Q$ and $a\in\Sigma$. We extend $\delta$ to $\delta\colon Q\times\Sigma^{*}\rightarrow 2^{Q}$ in the same way as for (non-symbolic) FAs. Without loss of generality, we may assume that each pair of states $q,q^{\prime}\in Q$ has just one predicate $\varphi$ such that $(q,\varphi,q^{\prime})\in\Delta$, since $\bot\in\varPsi$ and $\varPsi$ is closed under union. Let $L_{\_}q=\{w\in\Sigma^{*}\mid\delta(q,w)\cap F\neq\emptyset\}$ for $q\in Q$. The language $L(M)$ accepted by $M$ is $\bigcup_{\_}{q\in Q_{\_}0}L_{\_}q$. An SFA is called deterministic if $|Q_{\_}0|=1$ and $|\delta(q,a)|=1$ for all $q\in Q$ and $a\in\Sigma$. SFAs inherit many virtues of (non-symbolic) FAs. For example, one can effectively obtain the minimum DSFAs from SFAs and decide equivalence of two SFAs [21].

Argyros and D’Antoni [4] have given a MAT learner $\textsf{MAT}*$ for deterministic SFAs (DSFAs), assuming that a MAT learner $\Lambda$ for $\varPsi$ is available. That is, $\Lambda$ can learn $[\![\varphi]\!]\subseteq\Sigma$ for an arbitrary predicate $\varphi\in\varPsi$ with a MAT. The algorithm $\textsf{MAT}*$ uses instances $\Lambda^{(q,q^{\prime})}$ of $\Lambda$ to identify the predicate label of the transition edge from $q$ to $q^{\prime}$ and pretends to be a MAT for those predicate learner instances. Through communication between those predicate learners and the real MAT for the DSFA, it constructs a hypothesis DSFA. Accordingly, the query complexity of $\textsf{MAT}*$ depends on the design of $\Lambda$. In general, it requires very much less MQs than classical MAT learners using DFAs, when the alphabet is big but finite. If the alphabet is infinite, classical MAT learners have no hope to learn the language.

The target of this paper is residual symbolic finite automata (RSFAs). An RSFA $M$ is an SFA such that $L_{\_}q\in\mathit{Res}(L(M))$ for every state $q\in Q$. It is called reduced if $|Q|=|\mathit{Prm}(\mathit{Res}(L(M)))|$ and $L_{\_}q\in\mathit{Prm}(\mathit{Res}(L(M)))$ for each $q\in Q$.

3 Learning Algorithm for Residual Symbolic Finite Automata

Our learning algorithm for RSFAs can be seen as a combination of the RFA learner $\textsf{NL}*$ [7] and the DSFA leaner $\textsf{MAT}*$ [4]. This section presents how those can be combined and how the new difficulties raised by the combined setting shall be solved.

Our algorithm uses an observation table [2], which is used by $\textsf{NL}*$. An observation table is $\mathcal{T}=(U,V,T)$ where $U$ is a prefix-closed set of strings, $V$ is a set of strings, and $T$ is a map $T\colon UV\rightarrow\{+,-\}$. For each $u\in U$ and $v\in V$, we make $T(uv)=+$ if $uv\in L_{\_}*$ and $T(uv)=-$ otherwise for all $u\in U$ and $v\in V$ by asking an MQ on the string $uv$. An observation table can be viewed as a two-dimensional table whose $(u,v)$ entry is $T(uv)$ for $u\in U$ and $v\in V$. Let $\mathrm{row}(u)=\{\,v\in V\mid T(uv)=+\,\}$ for $u\in U$. To observe the relationship among residual languages is a key to acquire a (reduced) RFA for the target language $L_{\_}*$, but we cannot directly handle $u^{-1}L_{\_}*$. However, we can have a finite approximation $\mathrm{row}(u)=(u^{-1}L_{\_}*)\cap V$. The algorithm builds a hypothesis based on this information. Compared to the one constructed by $\textsf{NL}*$, our observation table differs in two points: (1) the domain of $T$ is $UV$ rather than $(U\cup U\Sigma)V$ and (2) $V$ is not necessarily suffix-closed. The first change is inevitable to handle huge alphabets. The second is an improvement from $\textsf{NL}*$. Giving up the idea of keeping $V$ suffix-closed reduces the size of $V$ and consequently the number of MQs.

Our algorithm builds a hypothesis SFA using the observation table and instances of the predicate learning algorithm, checks necessary conditions of the hypothesis to be an RSFA, asks an EQ and then updates the hypothesis by modifying the observation table and/or talking with the predicate learners. This procedure is repeated until an EQ is answered “yes”. The pseudo-code of our algorithm is shown in Algorithm 1. The hypothesis is rebuilt from scratch when the observation table is updated. Our algorithm assigns null to the variable $\mathcal{H}$ if the hypothesis has to be rebuilt.

At the beginning of the main loop, our algorithm calls Algorithm 2 to build a hypothesis $\mathcal{H}=(\mathcal{A},Q,Q_{\_}0,F,\Delta)$ with $Q=\{u\in U\mid\mathrm{row}(u)\in\mathit{Prm}(\{\mathrm{row}(u^{\prime})\mid u^{\prime}\in U\})\,\}$, $Q_{\_}0=\{u\in Q\mid\mathrm{row}(u)\subseteq\mathrm{row}(\epsilon)\}$ and $F=\{u\in Q\mid\epsilon\in\mathrm{row}(u)\}$, using the observation table $\mathcal{T}=(U,V,T)$. In order to construct $\Delta$, similarly to $\textsf{MAT}*$, we use the MAT learning algorithm $\Lambda$ for the underlying algebra $\varPsi$. After Algorithm 2 creates $|Q|^{2}$ instances $\Lambda^{(q,q^{\prime})}$ of $\Lambda$ for all pairs of states $q,q^{\prime}\in Q$, Algorithm 3 communicates with each $\Lambda^{(q,q^{\prime})}$ by pretending to be a MAT to obtain a transition predicate from $q$ to $q^{\prime}$. To avoid confusion with EQs and MQs from our algorithm to the MAT, we use small capital letters eq and mq for equivalence queries and membership queries from a predicate learner to our algorithm, respectively. When $\Lambda^{(q,q^{\prime})}$ asks an mq on $a\in\Sigma$, our algorithm answers $+$ if $\mathrm{row}(q^{\prime})\subseteq\{v\in V\mid\mathrm{MQ}(qav)=+\}$ and $-$ otherwise. When $\Lambda^{(q,q^{\prime})}$ asks an eq on $\varphi\in\varPsi$, our algorithm determines the transition predicate from $q$ to $q^{\prime}$ to be $\varphi$. An answer to the eq from the predicate learner will be generated by analyzing the built transitions or a counterexample for an EQ on the hypothesis automaton in the following steps. Execution of the predicate learner is suspended until a counterexample for the eq is found. When the algorithm is trying to answer an mq on $a$ from a predicate learner $\Lambda^{(q,q^{\prime})}$, if $\{v\in V\mid\mathrm{MQ}(qav)=+\}$ happens to be a new prime in $\{u^{-1}L_{\_}*\cap V\mid u\in U\cup\{qa\}\}$, $\mathcal{T}$ is extended to $(U\cup\{qa\},V,T^{\prime})$, and the procedure of building hypothesis restarts from the beginning.

After building a hypothesis, we check the following three conditions on the hypothesis by Algorithm 4 and modify the hypothesis if necessary, before raising an EQ. Those conditions ensure that our final output hypothesis will be a reduced RSFA.

• •

Condition 1: For $q,q^{\prime}\in Q$ and $a\in\Sigma$, $\mathrm{row}(q)\subseteq\mathrm{row}(q^{\prime})$ implies $\delta(q,a)\subseteq\delta(q^{\prime},a)$.

• •

Condition 2: For $u\in U$ and $x\in\delta(Q_{\_}0,u)$, we have $\mathrm{row}(x)\subseteq\mathrm{row}(u)$.

• •

Condition 3: For $q\in Q$ and $v\in V$, we have $v\notin\mathrm{row}(q)$ iff $v\notin L_{\_}q$.

Note that, in $\textsf{NL}*$, the automaton derived from an observation table always satisfies essentially the same conditions as above, which ensures that $\textsf{NL}*$ finally acquires the canonical RSA for the learning target language. The difference comes from the fact that $\textsf{NL}*$ makes a transition so that $q^{\prime}\in\delta(q,a)$ if and only if $\mathrm{row}(q^{\prime})\subseteq\{v\in V\mid\mathrm{MQ}(qav)=+\}$. On the other hand, the predicate $\varphi$ on the transition edge from $q$ to $q^{\prime}$ is determined by $\Lambda^{(q,q^{\prime})}$ in our setting, which ensures no special properties required to have the conditions. Therefore, we need additional processes to check the three conditions.

If some of the conditions is not satisfied, we modify the observation table or the transition relation so that the conditions shall be satisfied. The transition relation is updated by giving a counterexample to a predicate learner’s eq and receiving a new predicate hypothesis from it. For Condition 1, recall that $\delta(q,a)\subseteq\delta(q^{\prime},a)$ for all $a\in\Sigma$ if and only if $(q,\varphi,x),(q^{\prime},\varphi^{\prime},x)\in\Delta$ implies $[\![\varphi]\!]\subseteq[\![\varphi^{\prime}]\!]$, i.e., $[\![\varphi\wedge\neg\varphi^{\prime}]\!]=\emptyset$, for all $x\in Q$. By assumption, this can be confirmed effectively and when $\delta(q,a)\nsubseteq\delta(q^{\prime},a)$, one can find a witness $a\in[\![\varphi\wedge\neg\varphi^{\prime}]\!]$. Condition 2 can be checked by naively executing transitions reading all $u\in U$ from initial states. By performing this in length ascending order, if Condition 2 fails, one can find $u=u^{\prime}a\in U$ with $a\in\Sigma$, $x^{\prime}\in\delta(Q_{\_}0,u^{\prime})$ and $x\in\delta(x^{\prime},a)$ such that $\mathrm{row}(x^{\prime})\subseteq\mathrm{row}(u^{\prime})$ and $\mathrm{row}(x)\nsubseteq\mathrm{row}(u)$, thanks to the prefix-closedness of $U$. Condition 3 can also be checked by naively executing transitions reading all $v\in V$ from each $q\in Q$. Note that, since $V$ is not necessarily suffix-closed, differently from the previous case, we do not perform this in the length ascending order. If some $v\in V$ is found to falsify the condition, i.e. $\exists q\in Q,v\in\mathrm{row}(q)\Leftrightarrow v\notin L_{\_}q$, we find a suffix $av^{\prime}$ of $v$ with $a\in\Sigma$, which is not necessarily in $V$, such that $\mathrm{MQ}(qv^{\prime})=+\Leftrightarrow v^{\prime}\in L_{\_}q$ for all $q\in Q$ and $\mathrm{MQ}(q_{\_}2av^{\prime})=+\Leftrightarrow av^{\prime}\notin L_{\_}{q_{\_}2}$ for some $q_{\_}2\in Q$. Such a suffix $av^{\prime}$ can be found with $O(|Q|\log|v|)$ MQs using binary search on the suffixes of $v$, since $\mathrm{MQ}(q\epsilon)=+\Leftrightarrow\epsilon\in L_{\_}q$ for all $q\in Q$ and $\mathrm{MQ}(q_{\_}2v)=+\Leftrightarrow v\notin L_{\_}{q_{\_}2}$ for some $q_{\_}2\in Q$. Then, using such $a\in\Sigma$ and $q_{\_}2\in Q$, we modify the hypothesis. Note that by employing this technique, the query efficiency of $\textsf{NL}*$ [7], which requires $V$ to be suffix-closed, can be improved (Corollary 1).

When the hypothesis is confirmed to satisfy the three conditions above, the algorithm asks an EQ. We prove in Section 4 that if the hypothesis passes the equivalence test, it is a reduced RSFA.

When a counterexample $w$ is given to an EQ, we process the counterexample. Algorithm 5 is a modification of $\textsf{MAT}*$ for our non-deterministic hypothesis. At First, we check whether $\bigvee_{\_}{q\in Q_{\_}0}{\textrm{MQ}(qw)}=\textrm{MQ}(w)$. If not, $Q_{\_}0$ shall be refined by adding $w$ to $V$. If it is the case, we find a decomposition of $w=uav$ such that $u,v\in\Sigma^{*}$, $a\in\Sigma$ and $\bigvee_{\_}{q\in\delta(Q_{\_}0,u)}{\textrm{MQ}(qav)}\neq\bigvee_{\_}{q^{\prime}\in\delta(Q_{\_}0,ua)}{\textrm{MQ}(q^{\prime}v)}$. We have $\bigvee_{\_}{q\in Q_{\_}0}{\textrm{MQ}(qw)}=\textrm{MQ}(w)$ and $\bigvee_{\_}{q\in\delta(Q_{\_}0,w)}{\textrm{MQ}(q)}\neq\textrm{MQ}(w)$ because $\bigvee_{\_}{q\in\delta(Q_{\_}0,w)}{\textrm{MQ}(q)}=+\Leftrightarrow\delta(Q_{\_}0,w)\cap F\neq\emptyset$ and $w$ is a counterexample such that $\delta(Q_{\_}0,w)\cap F\neq\emptyset\Leftrightarrow\textrm{MQ}(w)=-$. This implies $\bigvee_{\_}{q\in\delta(Q_{\_}0,\epsilon)}{\textrm{MQ}(qw)}\neq\bigvee_{\_}{q\in\delta(Q_{\_}0,w)}{\textrm{MQ}(q)}$. Therefore, such a decomposition can be found with $O(|Q|\log|w|)$ MQs using binary search on the decompositions of $w$. This is a non-deterministic extension of the binary search technique in [20] for learning DFAs. Then, we can refine the transition from $q$ led by $a$.

4 Correctness and Termination

Although our hypothesis $\mathcal{H}$ is not guaranteed to be always an RFSA, the algorithm will eventually terminate and return a reduced RSFA accepting the target language.

Theorem 1**.**

When the hypothesis $\mathcal{H}$ passes the equivalence test, $\mathcal{H}$ is a reduced RSFA accepting the target language $L_{\_}*$.

One can prove Theorem 1 in the essentially same manner as for $\textsf{NL}*$ [7].

In order to evaluate the query complexity of our algorithm, we first discuss how many mqs and eqs a predicate learner $\Lambda^{q,q^{\prime}}$ may make. Let $D=\{\,a\in\Sigma\mid\mathrm{row}(q^{\prime})\subseteq\mathrm{row}(qa)\}$ be the set of letters $a\in\Sigma$ that $\Lambda^{q,q^{\prime}}$ is expected to learn, in accordance with how our learner answers mqs from $\Lambda^{q,q^{\prime}}$. To find a predicate for $D$, we refer to the minimum DSFA $M_{\_}*=(\mathcal{A},Q_{\_}*,q_{\_}0,F_{\_}*,\Delta_{\_}*)$ that accepts the learning target $L_{\_}*$. Note that $M_{\_}*$ is constructible from an arbitrary SFA for $L_{\_}*$ [21]. Let $r=\delta_{\_}*(q_{\_}0,q)$ and $Q_{\_}*^{D}=\{\,\delta_{\_}*(r,a)\mid a\in D\,\}$, where $\delta_{\_}*$ is the transition function induced by $\Delta_{\_}*$.111To be strict, the DSFA should be written as $(\mathcal{A},Q_{\_}*,\{q_{\_}0\},F_{\_}*,\Delta_{\_}*)$ and $\delta_{\_}*(q_{\_}0,q)$ is a singleton set according to what we have defined in the preliminary section, but here we follow the conventional notation for deterministic automata. Then we have $D=[\![\bigvee_{\_}{r^{\prime}\in Q_{\_}*^{D}}\varphi_{\_}{r,r^{\prime}}]\!]$ where $\varphi_{\_}{r,r^{\prime}}$ is the predicate on the edge from $r$ to $r^{\prime}$. Therefore, $\Lambda$ is indeed capable of learning $D$ and there are bounds on the numbers of eqs and mqs that $\Lambda$ makes, which we write as $\mathcal{C}_{\_}{\textrm{EQ}}({D})$ and $\mathcal{C}_{\_}{\textrm{MQ}}({D})$, respectively.

For each $L\in\mathit{Res}(L_{\_}*)$, let $\Gamma_{\_}{L}=\{\{a\in\Sigma\mid L^{\prime}=a^{-1}L\}\mid L^{\prime}\in\mathit{Res}(L_{\_}*)\}$. Then, the set of denotations of predicates that may appear in an automaton built by the learner during the learning process is represented as $\Phi=\{\bigcup_{\_}{D\in S}D\mid S\subseteq\Gamma_{\_}{L}\text{ for }L\in Res(L_{\_}*)\}$. Then the numbers of eqs and mqs that each predicate learner may make are bounded by $\mathcal{E}=\max_{\_}{D\in\Phi}\mathcal{C}_{\_}{\textrm{EQ}}(D)$ and $\mathcal{M}=\max_{\_}{D\in\Phi}\mathcal{C}_{\_}{\textrm{MQ}}(D)$, respectively.

Theorem 2**.**

Let $n=|\mathit{Res}(L_{\_}*)|$ and $m$ be the length of the biggest counterexample to an EQ returned by the MAT. Then, the proposed algorithm returns a reduced RSFA accepting $L_{\_}*$ using $\Lambda$ after raising at most $O(n^{4}\mathcal{E})$ EQs and $O(n^{6}(\mathcal{E}+\mathcal{M})+n^{5}\mathcal{E}\log m)$ MQs.

Proof.

At first, we will prove that the observation table $\mathcal{T}$ cannot be extended beyond $O(n^{2})$ times. Following [7], we create a tuple $(l_{\_}U,l,p,i)$ of measures where $l_{\_}U=|\{\mathrm{row}(u)\mid u\in U\}|$, $l=|R|$, $R=\{\{v\in V\mid uav\in L_{\_}*\}\mid u\in U,a\in\Sigma\cup\{\epsilon\}\}$, $p=|\mathit{Prm}(\{\mathrm{row}(u)\mid u\in U\})|$, $i=|\{(r,r^{\prime})\mid r,r^{\prime}\in R,r\subsetneq r^{\prime}\}|$. After each extension of the table, either (1) $l_{\_}U$ is increased or (2) $l$ is increased by $k>0$ and, simultaneously, $i$ is increased by at most $kl+k(k-1)/2$ or (3) $l$ stays the same and $i$ decreases or $p$ increase. However, $l_{\_}U$, $l$, $p$ cannot increase beyond $n$. Therefore, $\mathcal{T}$ cannot be extended beyond $O(n^{2})$ times.

Recall that $\Delta$ is updated only when a counterexample to some predicate learner is found. Such counterexamples are found at most $|\Delta|\mathcal{E}$ times without extending $\mathcal{T}$. $|\Delta|$ can be bounded by $O(n^{2})$. Thus, $\Delta$ is updated at most $O(n^{2}\mathcal{E})$ times without extending $\mathcal{T}$. Therefore, The algorithm must always reach an EQ and terminate after making at most $O(n^{4}\mathcal{E})$ EQs.

The algorithm asks MQs for (1) filling the observation table after extending the table, (2) answering mqs from predicate learners at Line 3 of Algorithm 3, (3) checking $\bigvee_{\_}{q\in Q_{\_}0}{\textrm{MQ}(qw)}\neq\textrm{MQ}(w)$ for a counterexample $w$ at Line 5 of Algorithm 5, (4) finding a decomposition of a counterexample at Line 5 of Algorithm 5, (5) finding a suffix of $v\in V$ which does not satisfy Condition 3 at Line 4 of Algorithm 4, and (6) the other purpose, where we check one or two rows for deciding whether to extend the observation table or to update the transition relation, after finding a decomposition of a counterexample or when one of the three conditions is found to be unsatisfied.

The total number of MQs used for (1) is $O(n^{3})$, because $|U|$ and $|V|$ is bounded by $n$ and $O(n^{2})$, respectively. Concerning (2), we use at most $|\Delta||V|\mathcal{M}$ MQs for each intermediate observation table $\mathcal{T}$. Thus, $O(n^{6}\mathcal{M})$ MQs are asked in total. We perform (3) and (4) at most $O(n^{4}\mathcal{E})$ times. For each event, (3) uses $O(n)$ MQs and (4) uses $O(n\log m)$ MQs. All in all, $O(n^{5}\mathcal{E}\log m)$ MQs are asked for (3) and (4). Each time (5) happens, $O(n\log m)$ MQs are raised, and (5) happens $O(n^{4}\mathcal{E})$ times. In total, $O(n^{5}\mathcal{E}\log m)$ MQs are asked for (5). For each decision of (6), $O(|V|)$ MQs are used, and it takes place $O(n^{4}\mathcal{E})$ times. Hence, $O(n^{6}\mathcal{E})$ MQs are made for (6). Therefore, the algorithm asks at most $O(n^{6}(\mathcal{E}+\mathcal{M})+n^{5}\mathcal{E}\log m)$ MQs. ∎

A query complexity comparison among previous algorithms and our algorithm for related classes of automata is shown in Table 1. The query complexity of the proposed algorithm is higher than that of $\textsf{MAT}*$ [4], especially for MQs. This is also true in the non-symbolic case. However, Bollig et al. [7] showed that in practice learning RFAs requires less queries than learning DFAs. In Section 5, we show that it is also the case in the learning of RSFAs and DSFAs.

We remark that the query efficiency of $\textsf{NL}*$ [7] can be improved by using our technique. The algorithm $\textsf{NL}*$ [7] adds all the suffixes of a counterexample to $V$, which makes $V$ suffix-closed and rather large. Suffix-closedness of $V$ ensures the correctness of $\textsf{NL}*$. Namely, the property is used in the proof of Lemma 2 of [6], which states that Condition 3 of our paper always holds for $\textsf{NL}*$. That is, by employing our counterexample processing and Condition 3 assurance procedure, the upper bound of the size of the table is improved from $O(n^{3}m|\Sigma|)$ to $O(n^{3}|\Sigma|)$ with additional $O(n^{3}\log m)$ MQs (binary search with $O(n\log m)$ MQs can occur $O(n^{2})$ times).

Corollary 1**.**

Canonical RFAs can be learned using $O(n^{2})$ EQs and $O(n^{3}|\Sigma|+n\log m)$ MQs.

5 Experiments

To evaluate the practical performance of our algorithm, we compare it with Argyros and D’Antoni’salgorithm $\textsf{MAT}*$ for DSFAs [4]. They implemented their algorithm on the open-source librarysymbolicautomata. Our algorithm is also implemented on the same library.

5.1 Setting

We generated learning target languages as follows, which can be seen as the symbolic counterpart of the languages given by Denis et al. [9] for comparing DFAs and RFAs. Denis et al. used NFAs over a two-letter alphabet for generating random regular languages. We use non-deterministic (not necessarily residual) SFAs over the entire 32-bit integers, i.e. $\Sigma=\{a\in\mathbb{N}\mid-2^{31}\leq a\leq 2^{31}-1\}$. SFAs we use are on the inequality algebra over $\Sigma$, whose atomic predicates are of the form $X\leq k$ for some $k\in\Sigma$, where $X$ is the free variable, and their semantics is given by $[\![X\leq k]\!]=\{\,a\in\Sigma\mid a\leq k\,\}$. Using negation, intersection and union, predicates define unions of intervals. We abbreviate $\neg(X\leq l)\wedge(X\leq r)$ to $l+1\leq X\leq r$. We also implemented a MAT learning algorithm for the algebra and used it as $\Lambda$. It learns arbitrary subsets $S\subseteq\Sigma$ by asking at most $K$ eqs and $O(K\log|\Sigma|)$ mqs using binary search where $K$ is the number of “borders” $|\{a\in\Sigma\mid a\in S\Leftrightarrow a-1\notin S\}|$ in the set $S$. SFAs are randomly generated using four parameters: the number $n_{\_}Q$ of states, the number $n_{\_}{\delta}$ of transitions per state, and the probabilities $p_{\_}I$ and $p_{\_}F$ for each state of being an initial and final state, respectively. For each state $q\in Q$, we randomly pick a destination state $q^{\prime}\in Q$ and two integers $l,r\in\Sigma$ such that $l\leq r$ and add $(q,\ l\leq X\leq r,\ q^{\prime})$ to $\Delta$. This addition is performed $n_{\_}{\delta}$ times for each state permitting duplication of the destination state. If we choose the same state $q^{\prime}$ twice or more as a destination of a state $q$, the transition predicate from $q$ to $q^{\prime}$ will be the union of two or more randomly chosen intervals. We used the parameters $n_{\_}Q=8$, $n_{\_}{\delta}=2$ and $p_{\_}I=p_{\_}F=0.5$ in our experiments.222The source code is available at https://github.com/ushitora/RSFA-QueryLearning.

5.2 Results

We generated 50,000 non-deterministic SFAs and let our algorithm learn the languages defined by those SFAs. Figures 2(a) and (b) show the average numbers of EQs and MQs raised by our algorithm relative to the number of the residual languages, respectively. The results are in contrast with our worst case analysis in Theorem 2. Our algorithm makes much fewer queries than $\textsf{MAT}*$. The gap between the numbers of the queries made by $\textsf{MAT}*$ and our algorithm looks even bigger than that between those by $\textsf{L}*$ and $\textsf{NL}*$ observed in the experiments performed by Bollig et al. [7] and by Angluin et al. [3]. In the remainder of this section, we discuss why using non-deterministic version should be more beneficial in the learning of symbolic automata than non-symbolic automata.

5.3 Analyses and Discussions

Denis et al. [9] have observed that most languages of randomly generated NFAs have few prime residual languages, i.e., the number of states of a reduced RFA tends to be much fewer than that of the minimum DFA for the same language. Even in the middle of the learning process, hypotheses built by our learner tend to be smaller than the ones by $\textsf{MAT}*$ (c.f. Fig. 3(a)), in spite of the worst case analysis. This tendency should be essentially the same in the non-symbolic and symbolic cases. However, the automaton size has a bigger effect on the query complexity in the symbolic case than in the non-symbolic case. Recall that most MQs and EQs to the MAT are used to answer mqs and eqs from the predicate learners when learning SFAs. We have $|Q|^{2}$ predicate learners if our current hypothesis has $|Q|$ states. As a consequence, the benefit in the query complexity to reduce the number of states in a hypothesis automaton is much bigger in SFA learning and thus using residual automata is quite advantageous.

In addition, when learning RSFAs, we are granted to be flexible to some extent in identification of transition predicates. Concerning a transition from $q$ to $q^{\prime}$, let $S_{\_}{\mathrm{saturated}}=\{a\in\Sigma\mid L_{\_}{q^{\prime}}\subseteq a^{-1}L_{\_}{q}\}$ and $S_{\_}{\mathrm{simplified}}=\{a\in\Sigma\mid L_{\_}{q^{\prime}}\subseteq a^{-1}L_{\_}{q},(\nexists q^{\prime\prime}\in Q,L_{\_}{q^{\prime}}\subsetneq L_{\_}{q^{\prime\prime}}\subseteq a^{-1}L_{\_}q)\}$. For any $\varphi$ with $S_{\_}{\mathrm{simplified}}\subseteq[\![\varphi]\!]\subseteq S_{\_}{\mathrm{saturated}}$, changing the transition predicate between $q$ and $q^{\prime}$ to $\varphi$ does not change the language defined by the automaton. That is, when learning an RSFA, as long as the predicate learner $\Lambda^{(q,q^{\prime})}$ outputs a predicate $\varphi$ satisfying $S_{\_}{\mathrm{simplified}}\subseteq[\![\varphi]\!]\subseteq S_{\_}{\mathrm{saturated}}$, the RFSA constructed using that output may pass the equivalence test. For instance, in the inequality algebra, when $S_{\_}{\mathrm{saturated}}$ consists of many intervals, a “lazy” predicate whose semantics consists of fewer intervals may be accepted, which can be achieved with fewer queries. This nature is not observed neither in RFAs nor DSFAs.

At last, we present another observation that explains why learning residual automata can be more efficient than deterministic ones, which applies to the non-symbolic case, too. To answer each mq from a predicate learner, our algorithm uses $|V|$ MQs to the MAT. Figure 3(b) shows the average of $|V|$ in our experiments. In the worst case analysis, $|V|$ may increase up to $O(n^{2})$, but in most of these experiments, $|V|$ is much smaller than $n$, which keeps the number of MQs in our algorithm small. An element $v$ is added to $V$ for denying at least one inclusion relation of a pair of rows, which occurs $O(n^{2})$ times in the worst case. In practice, one added element $v$ to $V$ may falsifies inclusions for many pairs of residual languages, while there is a lot of pairs between which inclusion properly hold, which will never been denied. Therefore, $|V|$ tends to be much smaller than the worst case, and it saves many MQs by our algorithm.

Acknowledgement

The research is supported by JSPS KAKENHI Grant Number JP18K11150.