Polynomial-Time Proactive Synthesis of Tree-to-String Functions from Examples

TL;DR

This paper presents a polynomial-time algorithm for synthesizing recursive tree-to-string functions from examples, with applications in pretty printing and serialization, addressing both user-provided and actively queried input/output data.

Contribution

It introduces a complete algorithm for learning tree-to-string transducers from examples, including an active learning approach that minimizes user input queries.

Findings

Polynomial-time solution under a closure condition

NP-completeness in the general case

Active learning algorithm with linear query complexity

Abstract

Synthesis from examples enables non-expert users to generate programs by specifying examples of their behavior. A domain-specific form of such synthesis has been recently deployed in a widely used spreadsheet software product. In this paper we contribute to foundations of such techniques and present a complete algorithm for synthesis of a class of recursive functions defined by structural recursion over a given algebraic data type definition. The functions we consider map an algebraic data type to a string; they are useful for, e.g., pretty printing and serialization of programs and data. We formalize our problem as learning deterministic sequential top-down tree-to-string transducers with a single state. The first problem we consider is learning a tree-to-string transducer from any set of input/output examples provided by the user. We show that this problem is NP-complete in general, but can be solved in polynomial time under a (practically useful) closure condition that each subtree of a tree in the input/output example set is also part of the input/output examples. Because coming up with relevant input/output examples may be difficult for the user while creating hard constraint problems for the synthesizer, we also study a more automated active learning scenario in which the algorithm chooses the inputs for which the user provides the outputs. Our algorithm asks a worst-case linear number of queries as a function of the size of the algebraic data type definition to determine a unique transducer.

Equations

$$\Sigma =\{$$

$$Q=\{$$

$$I=\{$$

$$\delta =\{$$

$$(\text{div},\text{Tag},()),(\text{pre},\text{Tag},()),(\text{span},\text{Tag},()),$$

$$(\text{cons},\text{List},(\text{Node},\text{List})),$$

$$(\text{nil},\text{List},())\}$$

$$\Sigma =$$

$$\Gamma =$$

$$\delta (\text{node})=$$

$$\delta (\text{div})=$$

$$\delta (\text{cons})=$$

$$\Gamma =$$

$$\displaystyle\delta(\text{node})=\$$

$$\displaystyle\delta(\text{div})=\$$

$$\displaystyle\delta(\text{cons})=\$$

$$\mathtt{morph}[\tau ](\text{node},0)$$

$$\mathtt{morph}[\tau ](\text{node},1)$$

$$\mathtt{morph}[\tau ](\text{node},2)$$

$$\mathtt{morph}[\tau ](\text{div},0)$$

$$\mathtt{morph}[\tau ](\text{pre},0)$$

$$\mathtt{morph}[\tau ]({\tau }_{\Sigma }(t))$$

$$\displaystyle=\$$

$$\tau (t)$$

$$\displaystyle=\$$

$$X_1$$

$$X_{1}p{X}_{2}q{X}_3$$

$$X_{1}pq{X}_2{X}_3=p{X}_{3}pq$$

$$X_{1}pq{X}_{2}p{X}_3{X}_2=ppqqpp$$

$$X_{1}pq{X}_2{X}_3=pqpqpp\wedge X_{2}p{X}_5=qpq$$

$$X_{1}pq{X}_2{X}_3=pqpqpp\wedge X_{1}p{X}_3{X}_2=pqppp$$

$${\tau }_{\Sigma }(t)=w$$

$${\tau }_{\Sigma }(\text{node}(\text{div},\text{nil}))$$

$${\tau }_{\Sigma }(\text{div})$$

$${\tau }_{\Sigma }(\text{cons}(\text{node}(\text{div},\text{nil}),\text{nil})$$

$$(\text{node},0)\cdot (\text{div},0)\cdot (\text{node},1)\cdot (\text{nil},0)\cdot (\text{node},2)$$

$$(\text{div},0)$$

$$(\text{span},0)$$

$$(\text{pre},0)$$

$$(\text{cons},0)\cdot (\text{node},0)\cdot (\text{div},0)\cdot (\text{node},1)\cdot (\text{nil},0)\cdot$$

$$(\text{node},2)\cdot (\text{cons},1)\cdot (\text{nil},0)\cdot (\text{cons},2)$$

$$(\text{nil},0)$$

$$(f,0)w_1(f,1)\cdots w_k(f,k)=w$$

Full text

The first problem we consider is learning a tree-to-string transducer from any set of input/output examples provided by the user. We show that, given a set of input/output examples, checking whether there exists a 1STS consistent with these examples is NP-complete in general. In contrast, the problem can be solved in polynomial time under a (practically useful) closure condition that each subtree of a tree in the input/output example set is also part of the input/output examples.

Because coming up with relevant input/output examples may be difficult for the user while creating hard constraint problems for the synthesizer, we also study a more automated active learning scenario in which the algorithm chooses the inputs for which the user provides the outputs. Our algorithm asks a worst-case linear number of queries as a function of the size of the algebraic data type definition to determine a unique transducer.

To construct our algorithms we present two new results on formal languages.

First, we define a class of word equations, called sequential word equations, for which we prove that satisfiability can be solved in deterministic polynomial time. This is in contrast to the general word equations for which the best known complexity upper bound is in linear space.

Second, we close a long-standing open problem about the asymptotic size of test sets for context-free languages. A test set of a language of words $L$ is a subset $T$ of $L$ such that any two word homomorphisms equivalent on $T$ are also equivalent on $L$. We prove that it is possible to build test sets of cubic size for context-free languages, matching for the first time the lower bound found 20 years ago.

1. Introduction

Synthesis by example has been very successful to help users deal with the tedious task of writing a program. This technique allows the user to specify input/output examples to describe the intended behavior of a desired program. Synthesis will then inspect the examples given by the user, and generalize them into a program that respects these examples, and that is also able to handle other inputs.

Therefore, synthesis by example allows non-programmers to write programs without programming experience, and gives experienced users one more way of programming that could fit their needs. Current synthesis techniques usually rely on domain-specific heuristics to try and infer the desired program from the user. When there are multiple (non-equivalent) programs which are compatible with input/output examples provided by the user, these heuristics may fail to choose the program that the user had in mind when writing the examples.

We believe it is important to have algorithms that provide formal guarantees based on strong theoretical foundations. Algorithms we aim for ensure that the solution is found whenever it exists in a class of functions of interest. Furthermore, the algorithms ensure that the generated program is indeed the program the user wants by detecting once the solution is unique and otherwise identifying a differentiating example whose output reduces the space of possible solutions.

In this paper, we focus on synthesizing printing functions for objects or algebraic data types (ADT), which are at the core of many programming languages. Converting such structured values to strings is very common, including uses such as pretty printing, debugging, and serialization. Writing methods to convert objects to strings is repetitive and usually requires the user to code himself mutually recursive toString functions. Although some languages have default printing functions, these functions are often not adequate. For example, the object Person(“Joe”, 31) might have to be printed “Joe is 31 years old” for better readability, or “<td>Joe</td><td>31</td>” if printed as part of an HTML table. How feasible is it for the computer to learn these “printing” functions from examples?

The state of the art in this context [27, 26] requires the user to provide enough examples. If the user gives too few examples, the synthesis algorithm is not guaranteed to return a valid printing function, and there is no simple way for the user to know which examples should be added so that the synthesis algorithm finishes properly.

Our contribution is to provide an algorithm that is able to determine exactly which questions to ask the user so that the desired function can be derived. Moreover, in order to learn a function, our algorithm (Algorithm 3) only needs to ask a linear number of questions (as a function of the size of the ADT declaration).

Our results hold for recursive functions that take ADT as input, and output strings. We model these functions by tree-to-string transducers, called single-state sequential top-down tree-to-string transducers [9, 14, 19, 27, 42], or 1STS for short. In this formalism, objects are represented as labelled trees, and a transducer goes through the tree top down in order to display it as a string. Single-state means the transducer keeps no memory as it traverses the tree. Sequential is a shorthand for linear and order-preserving, meaning that each subtree is printed only once (linear), and the subtrees of a node are displayed in order (order-preserving). In particular, such transducers cannot directly represent recursive functions that have extra parameters alongside the tree to print. Our work on 1STSs establishes a foundation that may be used for larger classes of transducers.

Our goal is to learn a 1STS from a set of positive input/output examples, called a sample. We prove the problem of checking whether there exists a 1STS consistent with a given sample is $\NP$-complete in general. Yet, we prove that when the given sample is closed under subtree, i.e., every tree in the sample has all of its subtrees in the sample, the problem of finding a compatible 1STS can be solved in polynomial time. For this, we reduce the problem of checking whether there exists an 1STS consistent with a sample to the problem of solving word equations. The best known algorithm to solve word equations takes linear space, and exponential time [39, 22]. However, we prove that the word equations we build are of a particular form, which we call sequential, and our first algorithm learns 1STSs by solving sequential equations in polynomial time.

We then tackle the problem of ambiguities that come from underspecified samples. More precisely, it is possible that, given a sample, there exist two 1STSs that are consistent with the sample, but that are not equivalent on a domain $D$ of trees. We thus define the notion of tree test set of a domain $D$, which guarantees that, any two 1STSs which are equivalent on the tree test set are also equivalent on the whole domain $D$. We give a method to build tree test sets of size $O(|D|^{3})$ from a domain of trees given as a non-deterministic top-down automaton. Our second learning algorithm takes as input a domain $D$, builds the tree test set of $D$, and asks for the user the output to all trees in the tree test set. Our second algorithm then invokes our first algorithm on the given sample.

This construction relies on fundamental results on a known relation between sequential top-down tree-to-string transducers and morphisms (a morphism is a function that maps the concatenation of two words to the concatenation of their images), and on the notion of test set [42]. Informally, a test set of a language of words $L$ is a subset $T\subseteq L$ such that any two morphisms which are equivalent on $T$ are also equivalent on $L$. In the context of 1STSs, the language $L$ is a context-free language, intuitively representing the yield of the domain $D$ mentioned above. Prior to our work announced in [32], the best known construction for a test set of a context-free grammar $G$ produced test sets of size $O(|G|^{6})$, while the best known lower bound was $O(|G|^{3})$ [37, 38]. We show the $O(|G|^{3})$ is in fact tight, and give a construction that, given any grammar $G$, produces a test set for $G$ of size $O(|G|^{3})$.

Finally, our third and, from a practical point of view, the main algorithm, improves the second one by analyzing the previous outputs entered by the user, in order to infer the next output. More specifically, the outputs previously entered by the user give constraints on the transducer being learned, and therefore restrict the possible outputs for the next questions. Our algorithm computes these possible outputs and, when there is only one, skips the question. Our algorithm only asks the user a question when there are at least two possible outputs for a particular input. The crucial part of this algorithm is to prove that such ambiguities happen at most $O(|D|)$ times. Therefore, our third algorithm asks the user only $O(|D|)$ questions, greatly improving our second one that asks $O(|D|^{3})$ questions. Our result relies on carefully inspecting the word equations produced by the input/output examples.

We implemented our algorithms in an open-source tool available at https://github.com/epfl-lara/prosy. In sections 9 and 10, we describe how to extend our algorithms and tool to ADTs which contain String (or Int) as a primitive type. We call the implementation of our algorithms proactive synthesis, because it produces a complete set of questions ahead-of-time whose answers will help to synthesize a unique tree-to-string function, filters out future questions whose answer could be actively inferred after each user’s answer, and produces suggestions as multiple choice or pre-filled answers to minimize the answering effort.

Contributions

Our paper makes the following contributions:

1. (1)

A new efficient algorithm to synthesize recursive functions from examples. We give a polynomial-time algorithm to obtain a 1STS from a sample closed under subtree. When the sample is not necessarily closed under subtree, we prove that the problem of checking whether there exists a 1STS consistent with the sample is $\NP$-complete (Section 6). This result is based on a fundamental contribution:

• •

A polynomial-time algorithm for solving a class of word equations that come from a synthesis problem (sequential word equations, Section 6). 2. (2)

An algorithm that synthesize recursive functions without ambiguity by generating an exhaustive set of questions to ask to the user, in the sense that any two recursive functions that agree on these inputs, are equal on their entire domain (Section 7). This is based on the following fundamental contribution:

• •

A constructive upper bound of $O(|G|^{3})$ on the size of a test set for a context-free grammar $G$, improving on the previous known bound of $O(|G|^{6})$ [37, 38] (Section 7). 3. (3)

A proactive and efficient algorithm that synthesizes recursive functions, which only requires the user to enter outputs for the inputs determined by the algorithm. Formally, we present an interactive algorithm to learn a 1STS for a domain of trees, with the guarantee that the obtained 1STS is functionally unique. Our algorithm asks the user only a linear number of questions (Section 8). 4. (4)

A construction of a linear tree test set for data types with Strings, which enables constructing a small set of inputs that distinguish between two recursive functions (Section 9). 5. (5)

An implementation of our algorithms as an interactive command-line tool (Section 10)

We note that the fundamental contributions of (• ‣ 1) and (• ‣ 2) are new general results about formal languages and may be of interest on their own.

For readability purposes, we only show proof sketches and intuition; detailed proofs are located in the Appendices.

2. Example Run of Our Synthesis Algorithm

To motivate our problem domain, we present a run of our algorithm on an example. The example is an ADT representing a context-free grammar. It defines its custom alphabet (Char), words (CharList), and non-terminals indexed by words (NonTerminal). A rule (Rule) is a pair made of a non-terminal and a sequence of symbols (ListSymbol), which can be non-terminals or terminals (Terminal). Finally, a grammar is a pair made of a (starting) non-terminal and a sequence of rules.

The input of our algorithm is the following file (written in Scala syntax):

⬇

abstract class Char

case class a() extends Char

case class b() extends Char

abstract class CharList

case class NilChar() extends CharList

case class ConsChar(c: Char, l: CharList) extends CharList

abstract class Symbol

case class Terminal(t: Char) extends Symbol

case class NonTerminal(s: CharList) extends Symbol

case class Rule(lhs: NonTerminal, rhs: ListSymbol)

abstract class ListRule

case class ConsRule(r: Rule, tail: ListRule) extends ListRule

case class NilRule() extends ListRule

abstract class ListSymbol

case class ConsSymbol(s: Symbol, tail: ListSymbol) extends ListSymbol

case class NilSymbol() extends ListSymbol

case class Grammar(s: NonTerminal, r: ListRule)

We would like to synthesize a recursive tree-to-string function print, such that if we compute, for example:

⬇

print(Grammar(NonTerminal(NilChar()),

ConsRule(Rule(NonTerminal(NilChar()),

  ConsSymbol(Terminal(a()),

    ConsSymbol(NonTerminal(NilChar()),

      ConsSymbol(Terminal(b()), NilSymbol())))),

  ConsRule(Rule(NonTerminal(NilChar()),

      NilSymbol())), NilRule())))

the result should be:

⬇

Start: N

N -> a N b

N ->

We would like the print function to handle any valid Grammar tree.

When given these class definitions above, our algorithm precomputes a set of terms from the ADT, so that any two single-state recursive functions which output the same Strings for these terms also output the same Strings for any term from this ADT. (This is related to the notion of tree test set defined in Section 7.2.) Our algorithm will determine the outputs for these terms by interacting with the user and asking questions. Overall, for this example, our algorithm asks the output for 14 terms.

For readability, question lines provided by the synthesizer are indented. Lines entered by the user finish by the symbol $\hookleftarrow{}$, meaning that she pressed the ENTER key. Everything after $\hookleftarrow{}$ on the same line is our comment on the interaction. “It” usually refers to the synthesizer. After few interactions, the questions themselves are shortened for conciseness. The interaction is the following:

⬇

Proactive Synthesis.

If you ever want to enter a new line, terminate your line by \ and press Enter.

What should be the function output for the following input tree?

a

a$\hookleftarrow{}$

What should be the function output for the following input tree?

b

b$\hookleftarrow{}$

NilChar ?

$\hookleftarrow{}$                  indeed, NilChar is an empty string.

NilSymbol ?

$\hookleftarrow{}$                  No symbol at the right-hand-side of a rule

NilRule ?

$\hookleftarrow{}$                  No rule left describing the grammar

What should be the function output for the following input tree?

Terminal(a)

Something of the form: […]a[…]

a$\hookleftarrow{}$                  Terminals contain only one char. Note the hint provided by the synthesizer.

NonTerminal(NilChar) ?

N$\hookleftarrow{}$

ConsChar(b,NilChar) ? Something of the form: […]b[…]

b$\hookleftarrow{}$                  A ConsChar is a concatenation of a char and a string

What should be the function output for the following input tree?

NonTerminal(ConsChar(b,NilChar))

1. Nb

2. bN

Please enter a number between 1 and 2, or 0 if you really want to enter your answer manually

1$\hookleftarrow{}$                  Note that it was able to infer only two possibilities, thus the closed question.

Grammar(NonTerminal(NilChar),NilRule) ? Something of the form: […]N[…]

Start: N$\hookleftarrow{}$

ConsSymbol(Terminal(a),NilSymbol) ? Something of the form: […]‘a‘[…]

a$\hookleftarrow{}$                 Symbols on the right-hand-side of a Rule are prefixed with a space

Rule(NonTerminal(NilChar),NilSymbol) ? Something of the form: […]N[…]

N ->$\hookleftarrow{}$            A rule with no symbols on the right-hand-side

ConsRule(Rule(NonTerminal(NilChar),NilSymbol),NilRule) ?

Something of the form: […]N ->[…]

$\hookleftarrow{}$                  A newline

N ->$\hookleftarrow{}$

What should be the function output for the following input tree?

Rule(NonTerminal(NilChar),ConsSymbol(Terminal(‘a‘),NilSymbol))

1. N ‘a‘->

2. N - ‘a‘>

3. N -> ‘a‘

4. N ‘a‘ ->

Please enter a number between 1 and 4, or 0 if you really want to enter your answer manually

3$\hookleftarrow{}$

The synthesizer then emits the desired recursive tree-to-string function, along with a complete set of the tests that determine it:

⬇

def print(t: Any): String = t match {

case a() $\Rightarrow$ "a"

case b() $\Rightarrow$ "b"

case NilChar() $\Rightarrow$ ""

case ConsChar(t1,t2) $\Rightarrow$ print(t1) + print(t2)

case Terminal(t1) $\Rightarrow$ "‘" + print(t1) + "‘"

case NonTerminal(t1) $\Rightarrow$ "N" + print(t1)

case Rule(t1,t2) $\Rightarrow$ print(t1) + " ->" + print(t2)

case ConsRule(t1,t2) $\Rightarrow$ "\n" + print(t1) + print(t2)

case NilRule() $\Rightarrow$ ""

case ConsSymbol(t1,t2) $\Rightarrow$ " " + print(t1) + print(t2)

case NilSymbol() $\Rightarrow$ ""

case Grammar(t1,t2) $\Rightarrow$ "Start: " + print(t1) + print(t2)

} // the part below is a contract, not needed to execute the recursive function

ensuring { (res: string) => res == (t match {

case a() => "a"

case b() => "b"

case NilChar() => ""

case NilSymbol() => ""

case NilRule() => ""

case Terminal(a()) => "a"

case NonTerminal(NilChar()) => "N"

case ConsChar(b(),NilChar()) => "b"

case NonTerminal(ConsChar(b(),NilChar())) => "Nb"

case Grammar(NonTerminal(NilChar()),NilRule()) => "Start: N"

case ConsSymbol(Terminal(a()),NilSymbol()) => " a"

case Rule(NonTerminal(NilChar()),NilSymbol()) => "N ->"

case ConsRule(Rule(NonTerminal(NilChar()),NilSymbol()),NilRule()) => "\nN ->"

case Rule(NonTerminal(NilChar()),ConsSymbol(Terminal(a()),NilSymbol())) => "N -> a"

case _ => res})

}

Observe that, in addition to the program, the synthesis system emits as a postcondition (after the ensuring construct) the recorded input/output examples (tests). Our work enables the construction of an IDE that would automatically maintain the bidirectional correspondence between the body of the recursive function and the postcondition that specifies its input/output tests. If the user modifies an example in the postcondition, the system could re-synthesize the function, asking for clarification in cases where the tests become ambiguous. If the user modifies the program, such system can regenerate the tests.

Depending on user’s answers, the total number of questions that the synthesizers asks varies (see section 11). Nonetheless, the properties that we proved for our algorithm guarantee that the number of questions remains at most linear as a function of the size of the algebraic data type declaration.

When the user enters outputs which are not consistent, i.e., for which there exists no printing function in the class of functions that we consider, our tool directly detects it and warns the user. For instance, for the tree ConsRule(Rule(NonTerminal(NilChar),NilSymbol),NilRule), if the user enters N- > with the space and the dash inverted, the system detects that this output is not consistent with the output provided for tree Rule(NonTerminal(NilChar),NilSymbol), and asks the question again.

⬇

We cannot have the transducer convert ConsRule(Rule(NonTerminal(NilChar),NilSymbol),NilRule)

to N- >.

Please enter something consistent with what you previously entered (e.g. ’N ->’,’N ->bar’,…)?

3. Discussion

3.1. Advantages of Synthesis Approach

It is important to emphasize that in the approach we outline, the developer not only enters less text in terms of the number of characters than in the above source code, but that the input from the user is entirely in terms of concrete input-output values, which can be easier to reason about for non-expert users than recursive programs with variable names and control-flow.

It is notable that the synthesizer in many cases offered suggestions, which means that the user often simply needed to check whether one of the candidate outputs is acceptable. Even in cases where the user needed to provide new parts of the string, the synthesizer in many cases guided the user towards a form of the output consistent with the outputs provided so far. Because of this knowledge, the synthesizer could also be stopped early by, for example, guessing the unknown information according to some preference (e.g. replacing all unknown string constants by empty strings), so the user can in many cases obtain a program by providing a very small amount of information.

Such easy-to-use interactions could be implemented as a pretty printing wizard in an IDE, for example triggered when the user starts to write a function to convert an ADT to a String.

Our experience in writing pretty printers manually suggests that they often require testing to ensure that the generated output corresponds to the desired intuition of the developer, suggesting that input-output tests may be a better form of specification even if in cases where they are more verbose. We therefore believe that it is valuable to make available to users and developers sucn an alternative method of specifying recursive functions, a method that can co-exist with the conventional explicitly written recursive functions and the functions derived automatically (but generically) by the compiler (such as default printing of algebraic data type values in Scala), or using polytypic programming approaches [21] and serialization libraries [34]. (Note that the generic approaches can reduce the boilerplate, but do not address the problem of unambiguously generalizing examples to recursive functions.)

3.2. Challenges in Obtaining Efficient Algorithms

The problem of inferring a program from examples requires recovering the constants embedded in the program from the results of concatenating these constants according to the structure of the given input tree examples. This presents two main challenges. The first one is that the algorithm needs to split the output string and identify which parts correspond to constants and which to recursive calls. This process becomes particularly ambiguous if the alphabet used is small or if some constants are empty strings. A natural way to solve such problems is to formulate them as a conjunction of word equations. Unfortunately, the best known deterministic algorithms for solving word equations run in exponential time (the best complexity upper bound for the problem takes linear space [39, 22]). Our paper shows that, under an assumption that, when specifying printing of a tree, we also specify printing of its subtrees, we obtain word equations solvable in polynomial time.

The next challenge is the number of examples that need to be solved. Here, a previous upper bound derived from the theory of test sets of context-free languages was $\Omega(n^{6})$, which, even if polynomial, results in impractical number of user interactions. In this paper we improve this theoretical result and show that tests sets are in fact in $O(n^{3})$, asymptotically matching the known lower bound.

Furthermore, if we allow the learning algorithm to choose the inputs one by one after obtaining outputs, the overall learning algorithm has a linear number of queries to user and to equation solving subroutine, as a function of the size of tree data type definition. Our contributions therefore lead to tools that have completeness guarantees with much less user input and a shorter running time than the algorithms based on prior techniques.

We next present our algorithms as well as the results that justify their correctness and completeness.

4. Notation

We start by introducing our notation and terminology for some standard concepts. Given a (partial) function from $f:A\to B$, and a set $C$, ${f}_{|{C}}$ denotes the (partial) function $g:A\cap C\to B$ such that $g(a)=f(a)$ for all $a\in A\cap C$.

A word (string) is a finite sequence of elements of a finite set $\Sigma$, which we call an alphabet.

A morphism $f:\Sigma^{*}\rightarrow\Gamma^{*}$ is a function such that $f(\varepsilon)=\varepsilon$ and for every $u,v\in\Sigma^{*}$, $f(u\cdot v)=f(u)\cdot f(v)$, where the symbol ‘$\cdot$’ denotes the concatenation of words (strings).

A non-deterministic finite automaton (NFA) is a tuple $(\Gamma,Q,q_{i},F,\delta)$ where $\Gamma$ is the alphabet, $Q$ is the set of states, $q_{i}\in Q$ is the initial state, $F$ is the set of final states, $\delta\subseteq Q\times\Gamma\times Q$ is the transition relation. When the transition relation is deterministic, that is for all $q,p_{1},p_{2}\in Q,a\in\Gamma$, if $(q,a,p_{1})\in\delta$ and $(q,a,p_{2})\in\delta$, then $p_{1}=p_{2}$, we say that $A$ is a deterministic finite automaton (DFA).

A context-free grammar $G$ is a tuple $(N,\Sigma,R,S)$ where:

• •

$N$ is a set of non-terminals,

• •

$\Sigma$ is a set of terminals, disjoint from $N$,

• •

$R\subseteq N\times(N\cup\Sigma)^{*}$ is a set of production rules,

• •

$S\in N$ is the starting non-terminal symbol.

A production $(A,\mathit{rhs})\in R$ is denoted ${A}\rightarrow{\mathit{rhs}}$. The size of $G$, denoted $|G|$, is the sum of sizes of each production in $R$: $\sum_{{A}\rightarrow{\mathit{rhs}}\in R}1+|\mathit{rhs}|$. A grammar is linear if for every production ${A}\rightarrow{\mathit{rhs}}\in R$, the $\mathit{rhs}$ string contains at most one occurrence of $N$. By an abuse of notation, we denote by $G$ the set of words produced by $G$.

4.1. Trees and Domains

A ranked alphabet $\Sigma$ is a set of pairs $(f,k)$ where $f$ is a symbol from a finite alphabet, and $k\in\mathbb{N}$. A pair $(f,k)$ of a ranked alphabet is also denoted ${f}^{({k})}$. We say that symbol $f$ has a rank (or arity) equal to $k$. We define by $\mathcal{T}_{\Sigma}$ the set of trees defined over alphabet $\Sigma$. Formally, $\mathcal{T}_{\Sigma}$ is the smallest set such that, if $t_{1},\dots,t_{k}\in\mathcal{T}_{\Sigma}$, and ${f}^{({k})}\in\Sigma$ for some $k\in\mathbb{N}$, then $f(t_{1},\dots,t_{k})\in\mathcal{T}_{\Sigma}$. A set of trees $T$ is closed under subtree if for all $f(t_{1},\dots,t_{k})\in T$, for all $i\in\{{1,\dots,k}\}$, $t_{i}\in T$.

A top-down tree automaton $T$ is a tuple $(\Sigma,Q,I,\delta)$ where $\Sigma$ is a ranked alphabet, $I\subseteq Q$ is the set of initial states, and $\delta\subseteq\Sigma\times Q\times Q^{*}$. The set of trees ${\mathcal{L}}({T})$ recognized by $T$ is defined recursively as follows. For ${f}^{({k})}\in\Sigma$, $q\in Q$, and $t=f(t_{1},\dots,t_{k})\in\mathcal{T}_{\Sigma}$, we have $t\in{\mathcal{L}}({T})_{q}$ iff there exists $(f,q,q_{1}\cdots q_{k})\in\delta$ such that for $1\leq i\leq k$, $t_{i}\in{\mathcal{L}}({T})_{q_{i}}$. The set ${\mathcal{L}}({T})$ is then defined as $\bigcup_{q\in I}{\mathcal{L}}({T})_{q}$.

Algebraic data types are described by the notion of domain, which is a set of trees recognized by a top-down tree automaton $T=(\Sigma,Q,I,\delta)$. The size of the domain is the sum of sizes of each transition in $\delta$, that is $\sum_{({f}^{({k})},q,q_{1}\cdots q_{k})\in\delta}1+k$.

Example 4.1**.**

In this example and the following ones, we illustrate our notions using an encoding of HTML-like data structures. Consider the following algebraic data type definitions in Scala:

⬇

abstract* class *Node

case* class node(t:** Tag,** l:** List)** extends *Node

abstract* class *Tag

case* class div()** extends *Tag

case* class pre()** extends *Tag

case* class span()** extends *Tag

abstract* class *List

case* class cons(n:** Node,** l:** List)** extends *List

case* class nil()** extends *List

The corresponding domain $D_{html}$ is described by the following:

[TABLE]

4.2. Transducers

A deterministic, sequential, single-state, top-down tree-to-string transducer $\tau$ (1STS for short) is a tuple $(\Sigma,\Gamma,\delta)$ where:

• •

$\Sigma$ is a ranked alphabet (of trees),

• •

$\Gamma$ is an alphabet (of words),

• •

$\delta$ is a function over $\Sigma$ such that $\forall{f}^{({k})}\in\Sigma.\ \delta(f)\in(\Gamma^{*})^{k+1}$.

Note that the transducer does not depend on a particular domain for $\Sigma$, but instead can map any tree from $\mathcal{T}_{\Sigma}$ to a word. Later, when we present our learning algorithms for 1STSs, we restrict ourselves to particular domains provided by the user of the algorithm.

We denote by ${\llbracket}{\tau}{\rrbracket}$ the function from trees to words associated with the 1STS $\tau$. Formally, for every ${f}^{({k})}\in\Sigma$, we have ${\llbracket}{\tau}{\rrbracket}(f(t_{1},\dots,t_{k}))=u_{0}\cdot{\llbracket}{\tau}{\rrbracket}(t_{1})\cdot u_{1}\cdots{\llbracket}{\tau}{\rrbracket}(t_{k})\cdot u_{k}$ if $\delta(f)=(u_{0},u_{1},\dots,u_{k})$. When clear from context, we abuse notation and use $\tau$ as a shorthand for the function ${\llbracket}{\tau}{\rrbracket}$.

Example 4.2**.**

A transducer $\tau=(\Sigma,\Gamma,\delta)$ converting HTML trees into a convenient syntax for some programmatic templating engines222https://github.com/lihaoyi/scalatags may be described by:

[TABLE]

In Scala, this is written as follows:

⬇

def* tau(input:** Tree)** = input match *{

• case node(t,** l)** $\Rightarrow$ "<." + tau(t)** + "" + tau(l)** + *""

• case div()** $\Rightarrow$ *"div"

• case pre()** $\Rightarrow$ *"pre"

• case span()** $\Rightarrow$ *"span"

• case cons(n,** l)** $\Rightarrow$ "(" + tau(n)** + ")" + tau(l)** + *""

• case nil()** $\Rightarrow$ *""

}

For example, tau(node(div,cons(node(span,nil,cons(node(pre,nil)))))) = "<.div(<.span())(<.pre())"

5. Transducers as Morphisms

For a given alphabet $\Sigma$, a 1STS $(\Sigma,\Gamma,\delta)$ is completely determined by the constants that appear in $\delta$. This allows us to define a one-to-one correspondence between transducers and morphisms. This correspondence is made through what we call the default transducer. More specifically, $\Gamma$ is the set $\overline{\Sigma}=\{{(f,i)\ |\ {f}^{({k})}\in\Sigma\land 0\leq i\leq k}\}$ and for all ${f}^{({k})}\in\Sigma$, we have $\delta(f)=((f,0),(f,1),\dots,(f,k))$. The default transducer produces sequences of pairs from $\overline{\Sigma}$.

Example 5.1**.**

For $\Sigma=\{\text{nil}^{(0)},\text{cons}^{(2)},\text{node}^{(2)},\text{div}^{(0)},\text{pre}^{(0)},\text{span}^{(0)}\}$, $\tau_{\Sigma}$ is:

[TABLE]

In Scala, $\tau_{\Sigma}$ can be written as follows ($+$ is used to concatenate elements and lists):

⬇

def* tauSigma(input:** Tree):** List[$\overline{\Sigma}$]** = input match *{

• case node(t,** l)** $\Rightarrow$ (node,0) + tauSigma(t)** + (node,1) + tauSigma(l)** + *(node,2)

• case div()** $\Rightarrow$ *(div,0)

• case pre()** $\Rightarrow$ *(pre,0)

• case span()** $\Rightarrow$ *(span,0)

• case cons(n,** l)** $\Rightarrow$ (cons,0) + tauSigma(n)** + (cons,1) + tauSigma(l)** + *(cons,2)

• case nil(n,** l)** $\Rightarrow$ *(nil,0)

}

Lemma 1**.**

For any ranked alphabet $\Sigma$, the function ${\llbracket}{\tau_{\Sigma}}{\rrbracket}$ is injective.

Following Lemma 1, for a word $w\in\overline{\Sigma}^{*}$, we define ${\sf tree}(w)$ to be the unique tree (when it exists) such that $\tau_{\Sigma}({\sf tree}(w))=w$. We show in Figure 1 how to obtain ${\sf tree}(w)$ in linear time from $w$.

For a 1STS $\tau=(\Sigma,\Gamma,\delta)$, we define the morphism ${\tt morph}[{\tau}]$ from $\overline{\Sigma}$ to $\Gamma^{*}$, and such that, for all ${f}^{({k})}\in\Sigma$, $i\in\{{0,\dots,k}\}$, ${\tt morph}[{\tau}](f,i)=u_{i}$ where $\delta(f)=(u_{0},u_{1},\dots,u_{k})$. Conversely, given a morphism $\mu:\overline{\Sigma}\to\Gamma^{*}$, we define ${\tt sts}({\mu})$ as $\tau_{\Sigma}$ where each output $l\in\overline{\Sigma}$ is replaced by $\mu(l)$.

Example 5.2**.**

For Example 4.2, ${\tt morph}[{\tau}]$ is defined by:

[TABLE]

Note that for any morphism: $\mu:\overline{\Sigma}\to\Gamma^{*}$, ${\tt morph}[{{\tt sts}({\mu})}]=\mu$ and for any 1STS $\tau$, ${\tt sts}({{\tt morph}[{\tau}]})=\tau$. Moreover, we have the following result, which expresses the output of a 1STS $\tau$ using the morphism ${\tt morph}[{\tau}]$.

Lemma 2**.**

For a 1STS $\tau$, and for all $t\in\mathcal{T}_{\Sigma}$, ${\tt morph}[{\tau}](\tau_{\Sigma}(t))=\tau(t)$.

Proof 5.3**.**

Follows directly from the definitions of ${\tt morph}[{\tau}]$ and $\tau_{\Sigma}$.

Example 5.4**.**

Let $t=\text{cons}(\text{node}(\text{div},\text{nil}),\text{nil})$. For ${\tt morph}[{}]$ defined as in Example 5.2 and the transducer $\tau$ as in Example 4.2, the left-hand-side of the equation of Lemma 2 translates to:

[TABLE]

Similarly, the right-hand-side of the equation can be computed as follows:

[TABLE]

We thus obtain that checking equivalence of 1STSs can be reduced to checking equivalence of morphisms on a context-free language.

Lemma 3** (See [42]).**

Let $\tau_{1}$ and $\tau_{2}$ be two 1STSs, and $D=(\Sigma,Q,I,\delta)$ a domain. Then ${{\llbracket}{\tau_{1}}{\rrbracket}}_{|{D}}={{\llbracket}{\tau_{2}}{\rrbracket}}_{|{D}}$ if and only if ${{\tt morph}[{\tau_{1}}]}_{|{G}}={{\tt morph}[{\tau_{2}}]}_{|{G}}$ where $G$ is the context-free language $\{{\tau_{\Sigma}(t)\ |\ t\in D}\}$.

Proof 5.5**.**

Follows from Lemma 2. $G$ is context-free, as it can be recognized by the grammar $(N_{G},\overline{\Sigma},R_{G},S_{G})$ where:

• •

$N_{G}=\{{S_{G}}\}\,\cup\,\{{A_{q}\ |\ q\in Q}\}$, where $S_{G}$ is a fresh symbol used as the starting non-terminal,

• •

The productions are:

\begin{array}[]{ll}R_{G}=&\{A_{q}\rightarrow\ (f,0)\cdot A_{q_{1}}\cdot(f,1)\cdots A_{q_{k}}\cdot(f,k)\ |\ {f}^{({k})}\in\Sigma\ \land(q,f,(q_{1},\dots,q_{k}))\in\delta\}\\ &\,\cup\,\{{{S_{G}}\rightarrow{A_{q}}\ |\ q\in I}\}\end{array}**

Note that the size of $G$ is linear in the size of $|D|$ (as long as there are no unused states in $D$).

6. Learning 1STS from a Sample

We now present a learning algorithm for learning 1STSs from sets of input/output examples, or a sample. Formally, a sample \mathcal{S}:\mathcal{T}_{\Sigma}\mathrel{\ooalign{\hfil\mapstochar$\hfil\cr$\to\cr}}\Gamma^{*} is a partial function from trees to words, or alternatively, a set of pairs $(t,w)$ with $t\in\mathcal{T}_{\Sigma}$ and $w\in\Gamma^{*}$ such that each $t$ is paired with at most one $w$.

6.1. NP-completeness of the general case

In general, we prove that finding whether there exists a 1STS consistent with a given a sample is an $\NP$-complete problem. To prove $\NP$-hardness, we reduce the one-in-three positive SAT problem. This problem asks, given a formula $\varphi$ with no negated variables, whether there exists an assignment such that for each clause of $\varphi$, exactly one variable (out of three) evaluates to true.

Theorem 1**.**

Given a sample $\mathcal{S}$, checking whether there exists a 1STS $\tau$ such that for all $(t,w)\in\mathcal{S}$, $\tau(t)=w$ is an $\NP$-complete problem.

Proof 6.1**.**

(Sketch) We can check for the existence of $\tau$ in $\NP$ using the following idea. Every input/output example from the sample gives constraints on the constants of $\tau$. Therefore, to check for the existence of $\tau$, it is sufficient to non-deterministically guess constants which are subwords of the given output examples. We can then verify in polynomial-time whether the guessed constants form a 1STS $\tau$ which is consistent with the sample $\mathcal{S}$.

To prove $\NP$-hardness, we consider a formula $\varphi$, instance of the one-in-three positive SAT. The formula $\varphi$ has no negated variables, and is satisfiable if there exists an assignment to the boolean variables such that for each clause of $\varphi$, exactly one variable (out of three) evaluates to true.

We construct a sample $\mathcal{S}$ such that there exists a 1STS $\tau$ such that for all $(t,w)\in\mathcal{S}$, $\tau(t)=w$ if and only if $\varphi$ is satisfiable. For each clause $(x,y,z)\in\varphi$, we construct an input/output example of the form $\mathcal{S}(x(y(z({\sf nil}))))=a\#$ where $x$, $y$ and $z$ are symbols of arity $1$ corresponding to the variables of the same name in $\varphi$, ${\sf nil}$ is a symbol of arity [math], and $a$ and $\#$ are two special characters. Moreover, we add an input/output example stating that $\mathcal{S}({\sf nil})=\#$.

This construction forces the fact that a 1STS $\tau$ consistent with $\mathcal{S}$ will have a non-empty output ($a$) for exactly one symbol out of $x$, $y$, and $z$ (therefore matching the requirements of one-in-three positive SAT formulas).

In the sequel, we prove that if the domain of the given sample is closed under subtree, this problem can be solved in polynomial time.

6.2. Word Equations

Our learning algorithm relies on reducing the problem of learning a 1STS from a sample to the problem of solving word equations. In general, the best known algorithm for solving word equations is in linear space [39, 22], and takes exponential time to run. When the domain of the sample $\mathcal{S}$ is closed under subtree, the equations we construct have a particular form, and we call them sequential formulas. We show there is a polynomial-time algorithm for checking whether a sequential word formula is satisfiable.

Definition 6.2**.**

Let $\mathbb{X}$ be a finite set of variables, and $\Gamma$ a finite alphabet. A word equation $e$ is a pair $y_{1}=y_{2}$ where $y_{1},y_{2}\in(\mathbb{X}\cup\Gamma)^{*}$. A word formula $\varphi$ is a conjunction of word equations. An assignment is a function from $\mathbb{X}$ to $\Gamma^{*}$, and can be seen as a morphism $\mu:(\mathbb{X}\cup\Gamma)\to\Gamma^{*}$ such that $\mu(a)=a$ for all $a\in\Gamma$.

A word formula is satisfiable if there exists an assignment $\mu:(\mathbb{X}\cup\Gamma)\to\Gamma^{*}$ such that for all equations $y_{1}=y_{2}$ in $\varphi$, $\mu(y_{1})=\mu(y_{2})$.

A word formula $\varphi$ is called sequential if:

1. for each equation $y_{1}=y_{2}\in\varphi$, $y_{2}\in\Gamma^{*}$ contains no variable, and $y_{1}\in(\Gamma\cup\mathbb{X})^{*}$ contains at most one occurrence of each variable,
2. for all equations $y=\_$ and $y^{\prime}=\_$ in $\varphi$, either $y$ and $y^{\prime}$ do not have variables in common, or ${y}_{|{\mathbb{X}}}={y^{\prime}}_{|{\mathbb{X}}}$, that is $y$ and $y^{\prime}$ have the same sequence of variables. We used the name sequential due to this last fact.

Example 6.3**.**

For $X_{1},X_{2},X_{3},X_{4},X_{5}\in\mathbb{X}$ and $p,q\in\Gamma^{*}$, each of the four formulas below is sequential:

[TABLE]

The following formulas (and any formula containing them) are not sequential:

[TABLE]

We prove that any sequential word formula $\varphi$ can be solved in polynomial time.

Lemma 1**.**

Let $\varphi$ be a sequential word formula. Let $n$ be the number of equations in $\varphi$, $V$ the number of variables, and $C$ be the size of the largest constant appearing in $\varphi$. We can determine in polynomial time $O(nVC)$ whether $\varphi$ is satisfiable. When it is, we can also produce a satisfying assignment for $\varphi$.

Proof 6.4**.**

(Sketch) We construct for each equation in $\varphi$ a DFA which represents succinctly all the possible assignments for this equation. Then, we take the intersection of all these DFAs, and obtain the possible assignments that satisfy all equations (i.e. the assignments that satisfy formula $\varphi$). The crucial part of the proof is to prove that this intersection can be computed in polynomial time, and does not produce an exponential blow-up as can be the case with arbitrary DFAs. We prove this by carefully inspecting the DFAs representing the assignments, and using the special form they have. We show the intersection of two such DFAs $A$ and $B$ is a DFA whose size is smaller than both the sizes of $A$ and $B$ (instead of being the product of the sizes of $A$ and $B$, as can be the case for arbitrary DFAs). See Figure 2 for an illustration of this intersection.

6.3. Algorithm for Learning from a Sample

Consider a sample $\mathcal{S}$ such that ${\mathit{d}om}(\mathcal{S})$ is closed under subtree. Given $(t,w)\in\mathcal{S}$, we define the word equation ${\sf equation}(t,w)$ as:

[TABLE]

where the left hand side $\tau_{\Sigma}(t)$ is a concatenation of elements from $\overline{\Sigma}$, considered as word variables, and the right hand side $w\in\Gamma^{*}$ is considered to be a word constant.

Assume all equations corresponding to a set of input/output examples are simultaneously satisfiable, with an assignment $\mu:\overline{\Sigma}\to\Gamma^{*}$. Our algorithm then returns the 1STS $\tau={\tt sts}({\mu})$, thus guarantying that $\tau(t)=w$ for all $(t,w)\in\Sigma$.

If the equations are not simultaneously satisfiable, our algorithm returns No.

Example 6.5**.**

For $\Sigma=\{\text{nil}^{(0)},\text{cons}^{(2)},\text{node}^{(2)},\text{div}^{(0)},\text{pre}^{(0)},\text{span}^{(0)}\}$, given the examples:

[TABLE]

we obtain the following equations:

[TABLE]

A satisfying assignment for these equations is the morphism ${\tt morph}[{\tau}]$ given in Example 5.2. Note that this assignment is not unique (see Example 7.1). We resolve ambiguities in Section 7.

To check for satisfiability of $\bigwedge_{(t,w)\in\mathcal{S}}{\sf equation}(t,w)$, we slightly transform the equations in order to obtain a sequential formula. For $(t,w)\in\mathcal{S}$, with $t=f(t_{1},\dots,t_{k})$, we define the word equation ${\sf regEquation}(t,w,\mathcal{S})$ as:

[TABLE]

where for all $i\in\{{1,\dots,k}\}$, $w_{i}=\mathcal{S}(t_{i})$. Note that $\mathcal{S}(t_{i})$ must be defined, since $t$ is in the domain of $\mathcal{S}$, which is closed under subtree. Moreover, the formula

[TABLE]

is satisfiable iff $\bigwedge_{(t,w)\in\mathcal{S}}{\sf equation}(t,w)$ is satisfiable.

Finally, $\varphi$ is a sequential formula. Indeed, two equations corresponding to trees having the same root ${f}^{({k})}\in\Sigma$ have the same sequence of variables $(f,0)\dots(f,k)$ in their left hand sides. And two equations corresponding to trees not having the same root have disjoint variables. Thus, using Lemma 1, we can check satisfiability of $\varphi$ in polynomial time (and obtain a satisfying assignment for $\varphi$ if there exists one).

Theorem 1** (Correctness and running time of Algorithm 1).**

Let $\mathcal{S}$ be a sample whose domain is closed under subtree. If there exists a 1STS $\tau$ such that $\tau(t)=w$ for all $(t,w)\in\mathcal{S}$, Algorithm 1 returns one such 1STS. Otherwise, Algorithm 1 returns No. Algorithm 1 terminates in time polynomial in the size of $\mathcal{S}$.

Proof 6.6**.**

Assume $\varphi$ has a satisfying assignment $\mu:\overline{\Sigma}\to\Gamma^{*}$, in step (2) of Algorithm 1. In that case, Algorithm 1 returns $\tau={\tt sts}({\mu})$. By definition of $\varphi$, we know, for all $(t,w)\in\mathcal{S}$, $\mu(\tau_{\Sigma}(t))=w$. Moreover, since ${\tt morph}[{\tau}]=\mu$, we have by Lemma 2 that $\tau(t)=\mu(\tau_{\Sigma}(t))$, so $\tau(t)=w$.

Conversely, if there exists $\tau$ such that $\tau(t)=w$ for all $(t,w)\in\mathcal{S}$. Then, again by Lemma 2, ${\tt morph}[{\tau}]$ is a satisfying assignment for $\varphi$, and Algorithm 1 must return Yes.

The polynomial running time follows from Lemma 1.

Remark 6.7**.**

For samples whose domains are not closed under subtree, we may modify Algorithm 1 to check for satisfiability of word equations which are not necessarily sequential. In that case, we are not guaranteed that the running time is polynomial.

7. Learning 1STSs Without Ambiguity

The issue with Algorithm 1 is that the 1STS expected by the user may be different than the one returned by the algorithm (see Example 7.1 below). To circumvent this issue, we use the notion of tree test set. Formally, a set of trees $T\subseteq D$ is a tree test set for the domain $D$ if for all 1STSs $\tau_{1}$ and $\tau_{2}$, ${{\llbracket}{\tau_{1}}{\rrbracket}}_{|{T}}={{\llbracket}{\tau_{2}}{\rrbracket}}_{|{T}}$ implies ${{\llbracket}{\tau_{1}}{\rrbracket}}_{|{D}}={{\llbracket}{\tau_{2}}{\rrbracket}}_{|{D}}$.

Example 7.1**.**

The transducer $\tau_{2}$ defined below satisfies the requirements of Example 6.5 but is different than the transducer in Example 4.2. Namely, the values in the box have been switched.

[TABLE]

We can verify that the two transducers are not equal on the domain $D_{html}$:

[TABLE]

Therefore, if a user had the 1STS $\tau$ in mind when giving the sample of Example 6.5, it is still possible that Algorithm 1 returns $\tau_{2}$. However, by definition of tree test set, if the sample given to Algorithm 1 contains a tree test set for $D_{html}$, we are guaranteed that the resulting transducer is equivalent to the transducer that the user has in mind, for all trees on $D_{html}$.

Our goal in this section is to compute from a given domain $D$ a tree test set for $D$. The notion of tree test set is derived from the well-known notion of test set in formal languages. The test set of a language $L$ (a set of words) is a subset $T\subseteq L$ such that for any two morphisms $f,g:\Sigma^{*}\rightarrow\Gamma^{*}$, ${f}_{|{T}}={g}_{|{T}}$ implies ${f}_{|{L}}={g}_{|{L}}$.

To compute a tree test set $T$ for $D$, we first compute a test set $T_{G}$ for the context-free language $G=\{{\tau_{\Sigma}(t)\ |\ t\in D}\}$ (built in Lemma 3), and then define $T=\{{{\sf tree}(w)\ |\ w\in T_{G}}\}$. We prove in Lemma 1 that $T$ is indeed a tree test set for $D$.

We introduce in Section 7.1 a new construction, asymptotically optimal, for building test sets of context-free languages. We show in Section 7.2 how this translates to a construction of a tree test set for a domain $D$. We also give a sufficient condition of $D$ so that the obtained tree test set is closed under subtree. This allows us to present, in Section 7.3, an algorithm that learns 1STSs from a domain $D$ in polynomial-time (by building the tree test set $T$ of $D$, and asking to the user the outputs corresponding to the trees of $T$).

7.1. Test Sets for Context-Free Languages

We show in this section how to build, from a context-free grammar $G$, a test set of size of $O(|G|^{3})$. Our construction is asymptotically optimal. We reuse lemmas from [37, 38], which were originally used to give a $O(|G|^{6})$ construction.

7.1.1. Plandowski’s Test Set

The following lemma was originally used in [37, 38] to show that any linear context-free grammar has a test set containing at most $O(|R|^{6})$ elements. We show in Section 7.1.2 how this lemma can be used to show a $2|R|^{3}$ bound.

Let $\Sigma_{4}=\{{a_{i},\overline{a_{i}},b_{i},\overline{b_{i}}\ |\ i\in\{{1,2,3,4}\}}\}$ be an alphabet. We define:

[TABLE]

and $T_{4}=L_{4}\setminus\{{b_{4}\,b_{3}\,b_{2}\,b_{1}\,\overline{b_{1}}\,\overline{b_{2}}\,\overline{b_{3}}\,\overline{b_{4}}}\}$.

The sets $L_{4},T_{4}\subseteq\Sigma_{4}$ have $16$ and $15$ elements respectively.

Lemma 1** ([37, 38]).**

$T_{4}$* is a test set for $L_{4}$.*

7.1.2. Linear Context-Free Grammars

We now prove that for any linear context-free grammar $G$, there exists a test set whose size is $2|R|^{3}$. Like the original proof of [37, 38] that gave a $O(|R|^{6})$ upper bound, our proof relies on Lemma 1. However, our proof uses a different construction to obtain the new, tight, bound.

Theorem 2**.**

Let $G=(N,\Sigma,R,S)$ be a linear context-free grammar. There exists a test set $T\subseteq G$ for $G$ containing at most $2|R|^{3}$ elements.

Proof 7.2**.**

(Sketch) Our proof relies on the fact that a linear grammar $G$ can be seen as a labelled graph whose nodes are non-terminals and whose transitions are rules of the grammar. A special node labelled $\bot$ is used for rules whose right-hand-sides are constant. We define the notion of optimal path in this graph. We use optimal paths to define paths which are piecewise optimal. More precisely, for $k\in\mathbb{N}$, a word belongs to the set $\Phi_{k}(G)$ if it can be derived in $G$ by a path that can be split into $k+1$ optimal paths. We then prove that $\Phi_{3}(G)$ forms a test set for $G$ (by using Lemma 1), which ends our proof as $\Phi_{3}(G)$ contains $O(|R|^{3})$ elements.

We make use of this theorem in the next section to obtain test sets for context-free grammars which are not necessarily linear.

7.1.3. Context-Free Grammars

To obtain a test set for a context-free grammar $G$ which is not necessarily linear, [37] constructs from $G$ a linear context-free grammar, $\text{Lin}(G)$, which produces a subset of $G$, and which is a test set for $G$.

Formally, $\text{Lin}(G)$ is derived from $G$ as follows:

• •

For every productive non-terminal symbol $A$ in G, choose a word $x_{A}$ produced by $A$.

• •

Every rule $r:A\to x_{0}A_{1}x_{1}\ldots A_{n}x_{n}$ in $G$, where for every $i$, $x_{i}\in\Sigma^{*}$ and $A_{i}\in N$ is productive, is replaced by $n$ different rules, each one obtained from $r$ by replacing all $A_{i}$ with $x_{A_{i}}$, except one.

Note that the definition of $\text{Lin}(G)$ is not unique, and depends on the choice of the words $x_{A}$. The following result holds for any choice of the words $x_{A}$.

Lemma 3** ([37, 38]).**

$\text{Lin}(G)$* is a test set for $G$.*

Using Theorem 2, we improve the $O(|G|^{6})$ bound of [37, 38] for the test set of $G$ to $2|G|^{3}$.

Theorem 4**.**

Let $G=(N,\Sigma,R,S)$ be a context-free grammar. There exists a test set $T\subseteq G$ for $G$ containing at most $2|G|^{3}$ elements.

Proof 7.3**.**

Follows from Theorem 2, Lemma 3, and from the fact that $\text{Lin}(G)$ has at most $|G|=\sum_{{A}\rightarrow{\mathit{rhs}}\in R}(|\mathit{rhs}|+1)$ rules. (When constructing $\text{Lin}(G)$, each rule ${A}\rightarrow{\mathit{rhs}}$ of $G$ is duplicated at most $|\mathit{rhs}|$ times.)

7.2. Tree Test Sets for Transducers

We use the results of the previous section to construct a tree test set for a domain $D$.

Lemma 1**.**

Any domain $D=(\Sigma,Q,I,\delta)$ has a tree test set $T$ of size at most $O(|D|)^{3}$. Moreover, if $I=Q$, then we can build $T$ such that $T$ is closed under subtree.

Proof 7.4**.**

Intuitively, we build the tree test set for $D$ by taking the set of trees corresponding to the test set of $G$, where $G$ is the grammar built in Lemma 3.

Let $\tau_{1}$ and $\tau_{2}$ be two 1STSs. Let $T_{G}$ be a test set for $G$. Define $T=\{{{\sf tree}(w)\ |\ w\in T_{G}}\}$. By Theorem 4, we can assume $T_{G}$ has size at most $|G|^{3}$, and hence, $T$ has size at most $|D|^{3}$. Let $\mu_{1}$ and $\mu_{2}$ be ${\tt morph}[{\tau_{1}}]$ and ${\tt morph}[{\tau_{2}}]$, respectively. We have:

[TABLE]

This ends the proof that $T$ is a tree test set for $D$.

We now show how to construct $T$ such that it is closed under subtree. For every non-terminal $A$ of $G$, we define the minimal word $w_{A}$. These words are built inductively, starting from the non-terminals which have a rule whose right-hand-side is only made of terminals. In the definition of $\text{Lin}(G)$, we use these words when modifying the rules of $G$ into linear rules.

When then define $T_{G}$ as the test set of $\text{Lin}(G)$ (which is also a test set of $G$), and $T=\{{{\sf tree}(w)\ |\ w\in T_{G}}\}\cup\{{{\sf tree}(w_{A})\ |\ A\in G}\}$. As shown previously, $T$ is a tree test set for $D$. We can now prove that $T$ is closed under subtree. Let $t=f(t_{1},\ldots,t_{k})\in T$. Let $i\in\{{1,\dots,k}\}$. We want to prove that $t_{i}\in T$.

We consider two cases. Either there exists $w\in T_{G}$ such that $t=f(t_{1},\ldots,t_{k})={\sf tree}(w)$, or there exists $A\in G$, $t=f(t_{1},\ldots,t_{k})={\sf tree}(w_{A})$.

• •

First, if there exists $w\in T_{G}$ such that $t=f(t_{1},\ldots,t_{k})={\sf tree}(w)$. Consider a derivation $p$ for $w$ in the $\text{Lin}(G)$. By construction of $\text{Lin}(G)$, the first rule is an $\varepsilon$-transition of the form ${S}\rightarrow{N}$ while the second rule is of the form:

[TABLE]

This second rule corresponds to a rule in $G$, of the form:

[TABLE]

We then have two subcases to consider. Either $i\neq j$, and in that case $t_{i}={\sf tree}(w_{i})$. By construction of $\text{Lin}(G)$, $w_{i}$ must be equal to $w_{A}$ for some $A\in G$. Thus, we have $t_{i}\in T$ by definition of $T$.

Or $i=j$, in that case $t_{i}={\sf tree}(w^{\prime})$, where $w^{\prime}$ is derived by the derivation $p$ where the first two derivation rules, outlined above, are replaced with the $\varepsilon$-rule ${S}\rightarrow{N_{i}}$. This production rule is ensured to exist in $\text{Lin}(G)$, as all states of $D$ are initial, so there exists a rule ${S}\rightarrow{N_{q}}$ for all $q\in Q$. (see definition of $G$ in Lemma 3). Then, since $w\in\Phi_{3}(\text{Lin}(G))$, and by construction of $\Phi_{3}(\text{Lin}(G))$, we conclude that $w^{\prime}\in\Phi_{3}(\text{Lin}(G))$. This ensures that $w^{\prime}\in T_{G}$, and $t_{i}\in T$.

• •

Otherwise, there exists $A\in G$ such that $t=f(t_{1},\dots,t_{k})={\sf tree}(w_{A})$. Using the fact that $w_{A}$ was build inductively in the grammar $G$, using other minimal words $w_{A^{\prime}}$ for $A^{\prime}\in G$, we deduce there exists $A^{\prime}\in G$ such that $t_{i}={\sf tree}(w_{A^{\prime}})$, and $t_{i}\in T$.

Lemma 2 shows the bound given in Lemma 1 is tight, in the sense that there exists an infinite class of growing domains $D$ for which the smallest tree test set has size $|D|^{3}$.

Lemma 2**.**

There exists a sequence of domains $D_{1},D_{2},\dots$ such that for every $n\geq 1$, the smallest tree test set of $D_{n}$ has at least $n^{3}$ elements, and the size of $D_{n}$ is linear in $n$. Furthermore, this lower bound holds even with the extra assumption that all states of the domain are initial.

Proof 7.5**.**

(Sketch) Our proof is inspired by the lower bound proof for test sets of context-free languages [37, 38]. For $n\geq 1$, we build a particular domain $D_{n}$ (whose states are all initial), and we assume by contradiction that it has a test set $T$ of size less than $n^{3}$. From this assumption, we expose a tree $t\in D_{n}$, as well as two 1STSs $\tau_{1}$ and $\tau_{2}$ such that ${\tau_{1}}_{|T}={\tau_{2}}_{|T}$ but $\tau_{1}(t)\neq\tau_{2}(t)$.

7.3. Learning 1STSs Without Ambiguity

Our second algorithm (see Algorithm 2) takes as input a domain $D$, and computes a tree test set $T\subseteq D$. It then asks the user the expected output for each tree $t\in T$. The user is modelled by a 1STS $\tau_{u}$ that can be used as an oracle in the algorithm. Algorithm 2 then runs Algorithm 1 on the obtained sample. The 1STS $\tau_{u}$ expected by the user may still be syntactically different the 1STS $\tau$ returned by our algorithm, but we are guaranteed that ${{\llbracket}{\tau}{\rrbracket}}_{|{D}}={{\llbracket}{\tau_{u}}{\rrbracket}}_{|{D}}$ (by definition of tree test set).

Theorem 1** (Correctness and running time of Algorithm 2).**

Let $\tau_{u}$ be a 1STS (used as an oracle), and $D=(\Sigma,Q,I,\delta)$ a domain such that $I=Q$. The output $\tau$ of Algorithm 2 is a 1STS $\tau$ such that ${{\llbracket}{\tau}{\rrbracket}}_{|{D}}={{\llbracket}{\tau_{u}}{\rrbracket}}_{|{D}}$.

Furthermore, Algorithm 2 invokes the oracle $O(|D|^{3})$ times, and terminates in time polynomial in $|D|$.

Proof 7.6**.**

The correctness of Algorithm 2 follows from the correctness of Algorithm 1 and from the fact that $T$ is a tree test set for $D$. The fact that Algorithm 2 invokes the algorithm $O(|D|^{3})$ times follows from the size of the tree test set (see Lemma 1).

Moreover, since all states of $D$ are initial, the tree test set of $D$ that we build is closed under subtree. The polynomial running time then follows from the fact that Algorithm 1 ends in polynomial time for samples whose domains are closed under subtree.

Remark 7.7**.**

Similarly to Algorithm 1, Algorithm 2 also applies for domains such that $I\neq Q$, but the running time is not guaranteed to be polynomial.

8. Learning 1STS Interactively

Our third algorithm (see Algorithm 3) takes as input a domain $D$, and computes a tree test set $T\subseteq D$. For this algorithm, we require from the beginning that all states of $D$ are initial, so that $T$ is closed under subtree. For a sample $\mathcal{S}$ such that ${\mathit{d}om}(\mathcal{S})$ is closed under subtree, and for $(t,w)\in\mathcal{S}$, we denote by ${\sf automaton}({t},{w})$ the automaton ${\sf automaton}({y},{w})$ where $y=w$ is the equation ${\sf regEquation}(t,w,\mathcal{S})$.

Instead of building the sample $\mathcal{S}$ and the intersection $\bigcap_{(t,w)\in\mathcal{S}}{\sf automaton}({t},{w})$ all at once, like algorithms 1 and 2 do, Algorithm 3 builds $\mathcal{S}$ and the intersection incrementally. It then uses the intermediary results to infer outputs, in order to avoid calling the oracle $\tau_{u}$ too many times. Overall, we prove that Algorithm 3 invokes the oracle $\tau_{u}$ at most $O(|D|)$ times, while Algorithm 2 invokes it $O(|D|^{3})$ times.

To infer outputs, Algorithm 3 maintains the following invariant for the while loop. First $\mathcal{S}$ is such that ${\mathit{d}om}(\mathcal{S})\subseteq T$, and its domain increases at each iteration. Then, for any ${f}^{({k})}\in\Sigma$, ${\tt sol}(f)$ is equal to $\bigcap_{(t,w)\in\mathcal{S}}{\sf automaton}({t},{w})$, and thus recognizes the set

[TABLE]

Intuitively, ${\tt sol}(f)$ represents the possible values for the output of $f$ in the transducer $\tau_{u}$, based on the constraints given so far.

To infer the output of a tree $t=f(t_{1},\dots,t_{k})$, for some ${f}^{({k})}\in\Sigma$, Algorithm 3 uses the fact that $\tau_{u}(f(t_{1},\dots,t_{k}))$ must be of the form $\mu(f,0)\mathcal{S}(t_{1})\mu(f,1)\cdots\mathcal{S}(t_{k})\mu(f,k)$ for some morphism $\mu:\overline{\Sigma}\to\Gamma$ satisfying $\bigwedge_{(t,w)\in\mathcal{S}}{\sf equation}(t,w)$. By construction, the NFA $A$, that recognizes the set $\{{x_{0}\,\mathcal{S}(t_{1})\,x_{1}\cdots\mathcal{S}(t_{k})\,x_{k}\ |\ x_{0}\#x_{1}\cdots\#x_{k}\in{\tt sol}(f)}\}$, recognizes exactly these words of the form $\mu(f,0)\mathcal{S}(t_{1})\mu(f,1)\cdots\mathcal{S}(t_{k})\mu(f,k)$.

We then check whether $A$ recognizes exactly one word $w$, in which case, we know $\tau_{u}(t)=w$, and we do not need to invoke the oracle. Otherwise, there are several alternatives which are consistent with the previous outputs provided by the user, and we cannot infer $\tau_{u}(t)$. We thus invoke the oracle (the user) to obtain $\tau_{u}(t)$.

Before proving the theorem corresponding to Algorithm 3, we give a lemma on words which we use extensively in the theorem.

Lemma 1**.**

Let $u,v,w\in\Gamma^{*}$. If $uv=vu$ and $uw=wu$ and $u\neq\varepsilon$, then $vw=wv$.

Proof 8.1**.**

A word $p\in\Gamma^{*}$ is primitive if there does not exist $r\in\Gamma^{*}$, $i>1$ such that $p=r^{i}$. Proposition 1.3.2 of [30] states that the set of words commuting with a non-empty word $u$ is a monoid generated by a single primitive word $p$. Since $v$ and $w$ both commute with $u$, there exist $i$ and $j$ such that $v=p^{i}$ and $w=p^{j}$, thus $vw=wv=p^{i+j}$.

The difficult part of Theorem 2 is to show the number of times the oracle $\tau_{u}$ is invoked is $O(|D|)$. We prove this by assuming by contradiction that the number of times $\tau_{u}$ is invoked is strictly greater than $3|D|+|Q|$ times. We prove this entails there are four trees which are nearly identical and for which our algorithm invokes the oracle (the four trees have the same root, and differ only for one child). Then, by a close analysis of the word equations corresponding to these four terms, we obtain a contradiction by proving our algorithm must have been able to infer the output for at least one of those terms.

Theorem 2** (Correctness and running time of Algorithm 3).**

Let $\tau_{u}$ be a 1STS (used as an oracle), and $D=(\Sigma,Q,I,\delta)$ a domain such that $I=Q$. The output $\tau$ of Algorithm 3 is a 1STS $\tau$ such that ${{\llbracket}{\tau}{\rrbracket}}_{|{D}}={{\llbracket}{\tau_{u}}{\rrbracket}}_{|{D}}$.

Algorithm 3 ends in time polynomial in $|D|$ and the number of times it invokes the oracle $\tau_{u}$ is in $O(|D|)$.

Proof 8.2**.**

(Sketch) The correctness and the polynomial running time of Algorithm 3 can be proved similarly to Algorithm 2. Note that we can check whether the NFA $A$ recognizes exactly one word. For that, we obtain a word $w$ that $A$ recognizes, and we intersect $A$ with the complement of an automaton recognizing $w$.

The crucial part of Algorithm 3 is that it invokes the oracle $\tau_{u}$ at most $O(|D|)$ times. More precisely, we show that Algorithm 3 invokes $\tau_{u}$ at most $|Q|+3\sum_{(q,{f}^{({k})},(q_{1},\dots,q_{k})\in\delta}1+k$ times, which is $|Q|+3|D|$, and in $O(|D|)$.

The main goal is to prove that for any trees four trees of the same root ($t_{a}$, $t_{b}$, $t_{c}$, $t_{d}$) differing from only one their $i$th subtree (respectively $t_{i}^{a}$, $t_{i}^{b}$, $t_{i}^{c}$, $t_{i}^{d}$), if we know the output of $\tau_{u}$ on all subtrees of $t_{a}$, $t_{b}$, $t_{c}$, $t_{d}$, then we can infer the output for at least one of $t_{a}$, $t_{b}$, $t_{c}$, $t_{d}$ based on the previous outputs. Let $x_{i}^{l}=\tau_{u}(t_{i}^{l})$ be the already known outputs of the sub-trees and $w_{l}=\tau_{u}(t_{l})$ the outputs to ask to the user, for $l\in\{{a,b,c,d}\}$. We obtain the following equations where $u,v$ represent the parts which do not change:

[TABLE]

We prove by contradiction that we could not have asked the user for all $w_{l}$ for $l\in\{{a,b,c,d}\}$, because at least one of the answer can be inferred from the previous ones. Here we illustrate two representative cases of the proof.

(1) One case is when $x_{i}^{a}$ and $x_{i}^{b}$ are neither prefix nor suffix of each other. By observing where $w_{a}$ and $w_{b}$ differ, we can recover $u$ and $v$, and the algorithm could have inferred $w_{c}$ and $w_{d}$.

(2) Another case is when $x_{i}^{a}$, $x_{i}^{b}$, and $x_{i}^{c}$ are respectively of the form $x_{1}$, $x_{1}x_{2}$ and $x_{1}x_{2}x_{3}$ for some $x_{1},x_{2},x_{3}\in\Gamma^{*}$ with $x_{2}x_{3}=x_{3}x_{2}$, and $x_{2}\neq\varepsilon$, $x_{3}\neq\varepsilon$. Since we asked the output $w_{a}$, $w_{b}$ and $w_{c}$, then after the first two questions, the values of $u$ and $v$ could not be determined. In particular, this means that there are some $u,v$ and $u^{\prime},v^{\prime}$ such that: $ux_{1}v=u^{\prime}x_{1}v^{\prime}$ and $ux_{1}x_{2}v=u^{\prime}x_{1}x_{2}v^{\prime}$ but $ux_{1}x_{2}x_{3}v\neq u^{\prime}x_{1}x_{2}x_{3}v^{\prime}$.

By assuming without loss of generality that $u=u^{\prime}u^{\prime\prime}$ and $v^{\prime}=v^{\prime\prime}v$, we obtain that $u^{\prime\prime}x_{1}=x_{1}v^{\prime\prime}$ and $u^{\prime\prime}x_{1}x_{2}=x_{1}x_{2}v^{\prime\prime}$, thus $v^{\prime\prime}x_{2}=x_{2}v^{\prime\prime}$, and then $x_{2}$ commutes with $v^{\prime\prime}$. Since $x_{2}$ also commutes with $x_{3}$, we deduce $v^{\prime\prime}$ commutes with $x_{3}$, and then $u^{\prime\prime}x_{1}x_{2}x_{3}=x_{1}x_{2}x_{3}v^{\prime\prime}$, which is a contradiction.

9. Tree with Values

Until now, we have considered a set of trees $\mathcal{T}_{\Sigma}$ which contained only other trees as subtrees, and with a test set of size $O(n^{3})$, although we have a linear learning time if we have interactivity. However, in practice, data structures such as XML are usually trees containing values. Values are typically of type $\mathrm{string}$or $\mathrm{int}$, and may be used instead of subtrees. For convenience, we will suppose that we only have $\mathrm{string}$ elements, and that $\mathrm{string}$ elements are rendered raw. We will demonstrate how we can directly obtain a test set of size $O(n)$.

Formally, let us add a special symbol $v\in\Sigma$, of arity 0, which has another version which can have a parameter. For each string $s\in\Gamma^{*}$ we can thus define the symbol $v_{s}$ and extend the notion of trees and domains as follows.

For a set of trees $\mathcal{T}$, we define the extended set $\mathcal{T}^{\prime}$ by:

[TABLE]

Note that given a domain $D$ and a height $h$, there is an infinite number of trees of height $h$ in $D^{\prime}$, while only a finite number in $D$. Fortunately, thanks to the semantics of the transducers on $v_{s}$ we define below, finding the tree test sets is easier in this setting.

For any transducer $\tau$ we extend the definition of ${\llbracket}{\tau}{\rrbracket}$ to $\mathcal{T}_{\Sigma}^{\prime}$ by defining ${\llbracket}{\tau}{\rrbracket}(v_{s})=s$. We naturally extend the definition of tree test set of an extended domain $D^{\prime}$ to be a set $T^{\prime}\subset D^{\prime}$ such that for all 1STSs $\tau_{1}$ and $\tau_{2}$, ${{\llbracket}{\tau_{1}}{\rrbracket}}_{|{T^{\prime}}}={{\llbracket}{\tau_{2}}{\rrbracket}}_{|{T^{\prime}}}$ implies ${{\llbracket}{\tau_{1}}{\rrbracket}}_{|{D^{\prime}}}={{\llbracket}{\tau_{2}}{\rrbracket}}_{|{D^{\prime}}}$. After proving the following lemma, we will state and prove the theorem on linear test sets.

Lemma 1**.**

For $a,b,x,y\in\Gamma^{*}$, $c\neq d$ in $\Gamma$, if $acx=bcy$ and $adx=bdy$, then $a=b$.

Proof 9.1**.**

Either $a$ or $b$ is a prefix of the other. Let us suppose that $a=bk$ for some suffix $k\in\Gamma^{*}$. It follows that $kcx=cy$ and $kdx=dy$. If $k$ is not empty, then $k$ starts with $c$ and with $d$, which is not possible. Hence $k$ is empty and $a=b$.

Theorem 2**.**

If the domain $D=(\Sigma,Q,I,\delta)$ is such that for every $f\in\Sigma$ of arity $k>0$, there exist trees in $t_{1},\ldots,t_{k}\in D$ such that $f(t_{1},\ldots,t_{k})\in D$ and each $t_{i}$ contains at least one $v$, then there exists a tree test set of $D^{\prime}$ of linear size $O(|\Sigma|\cdot A)$ where $A$ is the maximal arity of a symbol of $\Sigma$.

Proof 9.2**.**

(Intuition) Using the trees provided in the theorem’s hypothesis, we build a linear set of trees of $D^{\prime}$ where the $v$ nodes are replaced successively by two different symbols $v_{\text{``\#''}}$ and $v_{\text{``?''}}$. Then, we prove that any two 1STSs which are equal on this set of trees, are syntactically equal.

10. Implementation

Our tool (walkthrough in Section 2) is open-source and available at https://github.com/epfl-lara/prosy. It takes as input an ADT represented by case class definitions written in a Scala-like syntax, and outputs a recursive printer for this ADT. For the automata constructions of Algorithm 3, we used the brics Java library333http://www.brics.dk/automaton/.

In the walkthrough, notice that our tool gives propositions to the user so that the user does not have to enter the answers manually. The user may choose how many propositions are to be displayed (default is 9). To obtain these propositions, we use the following procedure. Remember that for each tree $t$ for which we need to obtain the output, Algorithm 3 builds an NFA $A$ that recognizes the set of all possible outputs for $t$ (see Section 8). We check for the existence of an accepted word $w_{0}$ in $A$, and compute the intersection $A_{1}$ between $A$ and an automaton recognizing all words except $w_{0}$. We then have two cases. Either $A_{1}$ is empty, and therefore we know the output for tree $t$ is $w_{0}$. In that case, we do not need to interact with the user, and can continue on to the next tree. Otherwise, $A_{1}$ recognizes some word $w_{1}\neq w_{0}$, which we display as a proposition to the user (alongside $w_{0}$). We then obtain $A_{2}$ as the intersection between $A$ and an automaton recognizing all words except $w_{0}$ and $w_{1}$. We continue this procedure until we have $9$ propositions (or whichever number the user entered), or when the intersected automaton becomes empty.

Concerning support for the String data type, we use ideas from Section 9 and reused our code from Algorithm 3 to infer outputs. Technically, we replace the String data type with an abstract class with two case classes, foo, and bar, that must be printed as “foo” and “bar” respectively. We then obtain an ADT without Strings, on which we apply the implementation of Algorithm 3 described above. We handle the Int and Boolean data types similarly, each with two different values which are not prefix of each other (we refer to the proof of theorem 2).

11. Evaluation

Although this work is mostly theoretical, we now depict through some benchmarks how many and which kind of questions our system is able to ask (Figure 3).

The first column is the name of the benchmark. The first two appear in Section 2 and in the examples. The third is a variation of the second where we add attributes as well, rendered “^.foo := "bar"”. The fourth is the same but rendered in XML instead of tags. Note that because we do not support duplication, we need to have a finite number of tags for XML.

The four rows “binary” illustrate how the number and type of questions may vary only depending on the user’s answers. We represent binary numbers as either Empty or Zero(x) or One(x) where x is a binary number. We put in parenthesis what a user willing to print Zero(One(Zero(Zero(One(Empty))))) would have in mind. The second and the third “discard” Zero when printing. The fourth one prints Empty as empty, Zero(x) as {x}ab and One(x) as a{x}b, which result in an ambiguity not resolved until asking a 3-digit number.

The last five rows of Figure 3 also illustrate how the number of asked questions grows linearly, whereas the number of elements in the test set grows cubically. These five rows represent a set of classes of type A taking as argument a class of type B, which themselves take as argument a class of type F. We report on the statistics by varying the number of concrete classes between 1, 2, 4, 8 and 16 (see proof of Lemma 2)

The second column is the size of the test set. For the last five rows, the test set contains a cubic number of elements. The third column is the number of answers our tool was able to “infer” based on previously “asked” questions, whose total number is in the fourth column. The fourth column plus the third one thus equal the second one.

Columns five, six and seven decompose the fourth column into the questions which were either asked without any indication, or with a hint of type “[…]foo[…]” (because the arguments were known), or with explicit suggestions where the user just had to enter a number for the choice (see Section 10).

12. Related Work

Our approach of proactively learning transducers by example, or tree-to-string programs, can be viewed as a particular case of Programming-by-Example. Programming-by-example, also named inductive programming [polozov_flashmeta:_2015] or test-driven synthesis [36], is gaining more and more attention, notably thanks to Flash Fill in Excel 2013 [16]. Subsequent work demonstrated that these techniques could widely be applicable not only to strings, but when extracting documents [28], normalizing text [24] and number transformations [41]. However, most state-of-the-art programming-by-example techniques rely on the fact that examples are unambiguous and/or that the example provider can check the validity of the final program [6] [43] [12]. The scope of their algorithms may be larger but they do not guarantee formal result such as polynomial time or non-ambiguity, and often require the user to come up with the examples by himself. More generally, synthesizing recursive functions has recently gained an interest among computer scientists from repairing fragments [25] to very precise types [40], even by formalizing programming-by-example  [13].

Recently, research has pointed out that solving ambiguities is a key to make programming by example accessible, trustful and reduce the number of errors [33][20]. The power of interaction is already well known in more statistical approaches, e.g. machine learning [44], although recent machine-learning based formatting techniques could benefit from more interaction, because they acknowledge some anomalies [35]. In [18] and even [17], the authors solve ambiguities by presenting different code snippets, obtained from synthesizing expressions of an expected type and from other sources of information. Nonetheless, the user has to choose between hard-to-read code snippets. Instead of asking which transducer is correct, we ask for what is the right output. Asking sub-examples at run-time proved to be a successful strategy when synthesizing recursive functions [1]. To deal with ambiguous samples, they developed a Saturate rule to ask for inputs covering the inferred program. In our case, however, such coverage rule still yield the ambiguity raised in example 7.1, leaving the chance of finding the right program to heuristics.

Researchers have investigated fundamental properties of tree-to-string or tree-to-word transducers [5], including expressiveness of even more complex classes than we consider [4], but none of them proposed a practical learning algorithm for such transducers. The situation is analogous for Macro Tree Transducers [7] [11]. Lemay [29] explores the synthesis of top-down tree-to-tree transducers using an algorithm similar to $L^{*}$ for automata [6] and tree automata [8]. These learning algorithms require the user to be in possession of a set of examples that uniquely defines the top-down tree transducer. We instead are able to incrementally ask for examples which resolve ambiguities, although our transducers are single-state. There are also probabilistic tree-to-string transducers [14], but they require the use of a corpus and are not adapted to synthesizing small-size code portions with a few examples.

A Gold-style learning algorithm [27, 26, 29] was created for sequential tree-to-string transducers. It runs in polynomial-time, but has a drawback: it requires the input/output examples to form a characteristic sample for the transducer which is being learned. The transducer which is being learned is however not known in advance. As such, it is not clear in practice how to construct such a characteristic sample. When the input/output examples do not form a characteristic sample, the algorithm might fail, and the user of the algorithm has no indication on which input/output examples should be added to obtain a characteristic sample.

In the case when trees to be printed are programming abstract syntax trees, our work is the dual of the mixfix parsing problem [23]. Mixfix parsing takes strings to parse and the wrapping constants to print the trees, and produces the shape of the tree for each string. Our approach requires the shape of the trees and strings of some trees, and produces the wrapping constants to print the trees.

12.1. Equivalence of top-down tree-to-string transducers

Since tree test sets uniquely define the behavior of tree-to-string transducers, they can be used for checking tree-to-word transducers equivalence. Checking equivalence of sequential (order-preserving, non-duplicating) tree-to-string transducers can already be solved in polynomial time [42], even when they are duplicating, and not necessarily order-preserving [31].

It was also shown [19] that checking equivalence of deterministic top-down macro tree-to-string transducers (duplication is allowed, storing strings in registers to output them later is allowed) is decidable. Complexity-wise, this result gives a co-randomized polynomial time algorithm for linear (non-duplicating) tree-to-string transducers. This complexity result was recently improved in [10], where it was proved that checking equivalence of linear tree-to-string transducers can be done in polynomial time.

12.2. Test sets

The polynomial time algorithms of [42, 10] exploit a connection between the problem of checking equivalence of sequential top-down tree-to-string transducers and the problem of checking equivalence of morphisms over context-free languages [42].

This latter problem was shown to be solvable in polynomial time [37, 38] using test sets. More specifically, this work shows that each context-free language $L$ has a (finite) test set whose size is $O(n^{6})$ (originally “finite” in [3, 15] and then “exponential” in [2]), where $n$ is the size of the grammar. They also provide a lower bound on the sizes of the test sets of context-free languages, by exposing a family of grammars for which the size of the smallest test is $O(n^{3})$.

As a result, when checking the equivalence of two morphisms $f$ and $g$ over a context-free language $L$, it is enough to check the equivalence on the test set of $L$ whose size is polynomial. This result translates (as described in [42]) to checking equivalence between sequential top-down tree-to-string transducers in the following sense. When checking the equivalence of two such transducers $P_{1}$ and $P_{2}$, it is enough to do so for a finite number of trees, which correspond to the test set of a particular context-free language. This language can be constructed from $P_{1}$ and $P_{2}$ in time $|P_{1}||P_{2}|$.

Remark 12.1**.**

Theorem 2 also helps improve the bound for checking equivalence of ${\sf 1STS}$ with states, using the known reduction from equivalence of ${\sf 1STS}$ with states to morphisms equivalence over a context-free language (reduction similar to Lemma 3, see [42, 26]).

13. Conclusion

We have presented a synthesis algorithms that can learn from examples tree-to-string functions with the input tree as the only argument. This includes functions such as pretty printers. Crucially, our algorithm can automatically construct a sufficient finite set of input trees, resulting in an interactive synthesis approach that in which the user needs to answer only a linear number of questions in the grammar size. Furthermore, the interaction process driven by our algorithm guarantees that there is no ambiguity: the recursive function of the expected form is unique for a given set of input-output examples. Moreover, we have analyzed the structure of word equations that the algorithm needs to solve and shown that they have a special structure allowing them to be solved in deterministic polynomial time, which results in overall polynomial running time of our synthesizer. Our results make a case that providing tests for tree-to-string functions is a viable alternative to writing the recursive programs directly, an alternative that is particularly appealing for non-expert users.

Appendix A Injectivity of $\tau_{\Sigma}$

See 1

Proof A.1**.**

Assume that ${\llbracket}{\tau_{\Sigma}}{\rrbracket}$ is not injective, and let $t=f(t_{1},\dots,t_{n})$ and $t^{\prime}=f^{\prime}(t_{1}^{\prime},\dots,t_{m}^{\prime})$ be two trees with $t\neq t^{\prime}$, such that $\tau_{\Sigma}(t)=\tau_{\Sigma}(t^{\prime})$. We pick $t$ and $t^{\prime}$ satisfying those conditions such that $\tau_{\Sigma}(t)$ has the smallest possible length.

By definition of $\tau_{\Sigma}$, we have

[TABLE]

and

[TABLE]

Since $\tau_{\Sigma}(t)=\tau_{\Sigma}(t^{\prime})$, we deduce that $(f,0)=(f^{\prime},0)$ and $f=f^{\prime}$, meaning that $t$ and $t^{\prime}$ have the same root.

Thus, $t=f(t_{1},\dots,t_{n})$, and $t^{\prime}=f(t_{1}^{\prime},\dots,t_{n}^{\prime})$.

To conclude, we consider two cases. If for all $i\in\{{1,\dots,n}\}$, $\tau_{\Sigma}(t_{i})=\tau_{\Sigma}(t_{i}^{\prime})$, we have $t_{i}=t_{i}^{\prime}$, as the length of $\tau_{\Sigma}(t_{i})$ is strictly smaller than $\tau_{\Sigma}(t)$. This ensures that $t=t^{\prime}$, and we obtain a contradiction.

On the other hand, if there exists $i\in\{{1,\dots,n}\}$, $\tau_{\Sigma}(t_{i})\neq\tau_{\Sigma}(t_{i}^{\prime})$, consider the smallest such $i$. We then have:

[TABLE]

and

[TABLE]

Since $\tau_{\Sigma}(t)=\tau_{\Sigma}(t^{\prime})$, and the prefixes are identical up until $(f,i-1)$, we deduce

[TABLE]

We finally consider three subcases, with respect to this last equation.

• •

If $\tau_{\Sigma}(t_{i})$ and $\tau_{\Sigma}(t_{i}^{\prime})$ have the same length, we deduce $\tau_{\Sigma}(t_{i})=\tau_{\Sigma}(t_{i}^{\prime})$, contradicting our assumption.

• •

If $\tau_{\Sigma}(t_{i})$ is strictly shorter than $\tau_{\Sigma}(t_{i}^{\prime})$, we deduce that $\tau_{\Sigma}(t_{i})(f,i)$ is a prefix of $\tau_{\Sigma}(t_{i}^{\prime})$. This is not possible as $\tau_{\Sigma}(t_{i}^{\prime})$ must be well parenthesized if $(f,0)$ is seen as an open parenthesis, and $(f,i)$ as a closing parenthesis (by definition of $\tau_{\Sigma}$).

• •

The case where $\tau_{\Sigma}(t_{i})$ is strictly longer than $\tau_{\Sigma}(t_{i}^{\prime})$ is symmetrical to the previous one.

Appendix B Proof of NP-completeness

See 1

Proof B.1**.**

In general, we can check for the existence of $\tau$ in $\NP$ using the following idea. Every input/output example from the sample gives constraints on the constants of $\tau$. Therefore, to check for the existence of $\tau$, it is sufficient to non-deterministically guess constants which are subwords of the given output examples. We can then verify in polynomial-time whether the guessed constants form a 1STS $\tau$ which is consistent with the sample $\mathcal{S}$.

To prove $\NP$-hardness, we consider a formula $\varphi$, instance of the one-in-three positive SAT. The formula $\varphi$ has no negated variables, and is satisfiable if there exists an assignment to the boolean variables such that for each clause of $\varphi$, exactly one variable evaluates to true.

Formally, let $\mathbb{X}$ be a set of variables and let $\varphi\equiv C_{1}\land\dots\land C_{n}$ such that for every $i\in\{{1,\dots,n}\}$, $C_{i}\equiv{\sf OneInThree}(x^{i}_{1},x^{i}_{2},x^{i}_{3})$ with $x^{i}_{1},x^{i}_{2},x^{i}_{3}\in\mathbb{X}$.

Let $\Sigma={{\sf nil}}^{({0})}\cup\{{{x}^{({1})}\ |\ x\in\mathbb{X}}\}$. Let $\Gamma=\{{a,\#}\}$. Then, for every clause ${\sf OneInThree}(x^{i}_{1},x^{i}_{2},x^{i}_{3})$, we define $\mathcal{S}(x^{i}_{1}(x^{i}_{2}(x^{i}_{3}({\sf nil}))))=a\#$. Finally, we define $\mathcal{S}({\sf nil})=\#$.

We now prove the following equivalence. There exists a 1STS $\tau$ such that for all $(t,w)\in\mathcal{S}$, $\tau(t)=w$ if and only if $\varphi$ is satisfiable.

$(\Rightarrow)$* Let $\tau=(\Sigma,\Gamma,\delta)$ be a 1STS such that for all $(t,w)\in\mathcal{S}$, $\tau(t)=w$ By definition of $\mathcal{S}$, we know $\tau({\sf nil})=\#$ and and for all $i\in\{{1,\dots,n}\}$, $\tau(x^{i}_{1}(x^{i}_{2}(x^{i}_{3}({\sf nil}))))=a\#$.*

Moreover, if for all $x\in\mathbb{X}$, we denote $\delta(x)=({\sf left}({x}),{\sf right}({x}))$, with ${\sf left}({x}),{\sf right}({x})\in\Gamma^{*}$. Then, by definition of $\tau$, we have, for $i\in\{{1,\dots,n}\}$:

[TABLE]

We deduce that ${\sf left}({x^{i}_{1}}){\sf left}({x^{i}_{2}}){\sf left}({x^{i}_{3}})=a$ and ${\sf right}({x^{i}_{3}}){\sf right}({x^{i}_{2}}){\sf right}({x^{i}_{1}})=\varepsilon$.

Thus, exactly one of ${\sf left}({x^{i}_{1}})$, ${\sf left}({x^{i}_{2}})$, ${\sf left}({x^{i}_{3}})$ must be equal to $a\in\Gamma$, while the other two must be equal to $\varepsilon$. Then, $\varphi$ is satisfiable using the boolean assignment that maps a variable $x\in\mathbb{X}$ to $\top$ if ${\sf left}({x})=a$, and to $\bot$ if ${\sf left}({x})=\varepsilon$.

$(\Leftarrow)$* Conversely, assume there exists a satisfying assignment $\mu:\mathbb{X}\to\{{\bot,\top}\}$ for $\varphi$. Then, we define the 1STS $\tau=(\Sigma,\Gamma,\delta)$ where $\delta({\sf nil})=\#$ and for all $x\in\mathbb{X}$ $\delta(x)=(a,\varepsilon)$ if $\mu(x)=\top$, and $\delta(x)=(\varepsilon,\varepsilon)$ if $\mu(x)=\bot$. We then have $\tau(t)=w$ for all $(t,w)\in\mathcal{S}$.*

Remark B.2**.**

The NP-completeness proof of [26] could not apply here, because the transducers are more general. Namely, they are allowed to have multiple states in their setting.

Appendix C Solving Sequential Word Equation in Polynomial Time

See 1

Proof C.1**.**

By definition of sequential, $\varphi$ can be written as $\varphi_{1}\land\dots\land\varphi_{l}$ for some $l\in\mathbb{N}$, where for $i\neq j$, $\varphi_{i}$ and $\varphi_{j}$ do not have variables in common. We can thus check for satisfiability of $\varphi$ by checking satisfiability of each $\varphi_{i}$ independently. Let $\psi$ be one of $\varphi_{i}$ for $i\in\{{1,\dots,l}\}$.

By definition of sequential, we know there exists $n\in\mathbb{N}$ with $\psi\equiv y_{1}=w_{1}\,\land\dots\land\,y_{n}=w_{n}$, and there exist $k\in\mathbb{N}$ and $X_{0},\dots,X_{k}\in\mathbb{X}$, such that for all $i\in\{{1,\dots,n}\}$, $w_{i}\in\Gamma^{*}$, and ${y_{i}}_{|{\mathbb{X}}}=X_{0}\cdots X_{k}$.

The outline of the proof is the following. For $i\in\{{1,\dots,n}\}$, we build an acyclic DFA, denoted $A_{i}={\sf automaton}({y_{i}},{w_{i}})$, that recognizes the set

[TABLE]

where $\#$ is a special character we introduce, used as a separator.

Then, there exists an assignment $\mu:\mathbb{X}\rightarrow\Gamma^{*}$ such that for all $i\in\{{1,\dots,n}\}$, $\mu(y_{i})=w_{i}$ if and only if $A_{1}\cap\dots\cap A_{n}\neq\emptyset$. We then show that the emptiness of this intersection can be checked in polynomial time, due to the particular form of the automata. (In general, checking the emptiness of the intersection of $n$ automata is a $\PSPACE$-complete problem, and thus takes exponential time to check.)

We now give the formal details of the proof. Let $i\in\{{1,\dots,n}\}$, and $y_{i}=X_{0}u_{1}X_{1}\cdots u_{k}X_{k}$. We define $A_{i}={\sf automaton}({y_{i}},{w_{i}})=(Q_{i},q_{i},\delta_{i})$ as follows:

• •

$Q_{i}=\{{0,\dots,k}\}\times\{{0,\dots,|y_{i}|}\}$* is the set of states,*

• •

$q_{i}=(0,0)$* is the initial state,*

• •

for $a\in\{{0,\dots,k}\}$, $b\in\{{0,\dots,|y_{i}|}\}$,

• –

$\delta((a,b),\#)=(a+1,b+|u_{a+1}|)$* *

if $a<k$ and ${y_{i}}[b,b+|u_{a+1}|]=u_{a+1}$,

• –

$\delta((a,b),\sigma)=(a,b+1)$* if the *$(b+1)$th letter of $|y_{i}|$ is $\sigma$.

We now prove that the intersection $A_{1}\cap\dots\cap A_{n}$ can be represented by an automaton which has as many states as the smallest $A_{i}$. We first compute the intersection between $A_{1}$ and $A_{2}$, and show that the resulting automaton can be obtained from $A_{1}$ by deleting transitions (see Figure 2).

We denote the states of $A_{1}$ by $P=\{{{p}_{({i},{j})}\ |\ i\in\{{0,\dots,k}\},j\in\{{0,\dots,|w_{1}|}\}}\}$ and the states of $A_{2}$ by $Q=\{{{q}_{({i},{j})}\ |\ i\in\{{0,\dots,k}\},j\in\{{0,\dots,|w_{2}|}\}}\}$.

Let $y_{1}=X_{0}u_{1}X_{1}\cdots u_{k}X_{k}$, and $y_{2}=X_{0}v_{1}X_{1}\cdots v_{k}X_{k}$, where $u_{1},\dots,u_{k},v_{1},\dots,v_{k}\in\Gamma^{*}$

We know that whenever there is a transition from a state ${p}_{({i},{j})}$ to ${p}_{({i^{\prime}},{j^{\prime}})}$ in $A_{1}$ then either:

• •

$i^{\prime}=i$* and $j^{\prime}=j+1$ ($\Gamma$-transitions), or*

• •

$i^{\prime}=i+1$* and $j^{\prime}=j+|u_{i+1}|$ ($\#$-transitions)*

The same property holds for $A_{2}$, by replacing $u_{i+1}$ with $v_{i+1}$.

We compute the cartesian product $B_{2}$ of $A_{1}$ and $A_{2}$. The states of $B_{2}$ are pairs from $P\times Q$. Consider such a state $({p}_{({i},{j})},{q}_{({i^{\prime}},{j^{\prime}})})$ which is reachable in $B_{2}$ from the initial state $({p}_{({0},{0})},{q}_{({0},{0})})$.

First, we can show that $i=i^{\prime}$. The only transitions that increase $i$ and $i^{\prime}$ in $A_{1}$ and $A_{2}$ are $\#$-transitions, and they increase $i$ and $i^{\prime}$ by $1$. Thus, in the cartesian product $B_{2}$, we always have $i=i^{\prime}$.

Similarly, the following invariant holds for the reachable states $({p}_{({i},{j})},{q}_{({i},{j^{\prime}})})$ of $B_{2}$:

[TABLE]

In particular, this means that each state $p\in P$ can be paired with at most one state $q\in Q$ in $B_{2}$ (and each state of $Q$ can be paired with at most one state of $P$). This entails that $B_{2}$ can be obtained from $A_{1}$ or $A_{2}$ by erasing transition, and that it has at most as many reachable states as $min(|P|,|Q|)$.

For $3\leq i\leq n$, we then compute $B_{i}=A_{i}\cap B_{i-1}$ similarly, and obtain that $B_{n}=A_{1}\cap\dots\cap A_{n}$ has at most as many reachable states as the smallest $A_{i}$.

Appendix D Test Sets for Linear Context-Free Grammars

See 2

Proof D.1**.**

Before building the test set, we introduce some notation.

Graph of $G$.

Define the labeled graph ${\sf graph}(G)=(V,E)$ where $V=N\cup\{{\bot}\}$, $\bot$ is a new symbol, and $E\subseteq V\times R\times V$ such that:

• •

for non-terminals $A,B\in N$ and a rule $r\in R$, let $(A,r,B)\in E$ iff $r$ is of the form ${A}\rightarrow{uBv}$ where $u,v\in\Sigma^{*}$ (i.e., $B$ is the only non-terminal occurring in $\mathit{rhs}$).

• •

for a non-terminal $A\in N$ and $r\in R$, $(A,r,\bot)\in E$ if and only if $r={A}\rightarrow{\mathit{rhs}}$ for some $\mathit{rhs}\in\Sigma^{*}$.

A path of ${\sf graph}(G)$ is a (possibly cyclic) sequence of edges of $E$, of the form: $(A_{1},r_{1},A_{2})\cdot(A_{2},r_{2},A_{3})\cdots(A_{n},r_{n},A_{n+1})$. A path is accepting if $A_{1}=S$ and $A_{n+1}=\bot$.

Link between ${\sf graph}(G)$ and $G$.

Given a rule ${A}\rightarrow{uBv}\in R$, where $A,B\in N$ and $u,v\in\Sigma^{*}$, we denote $\pi({r})=u$ and $\overline{\pi}({r})=v$. For a rule of the form ${A}\rightarrow{u}$ where $u\in\Sigma^{*}$ we denote $\pi({r})=u$ and $\overline{\pi}({r})=\varepsilon$. For a path $P=(A_{1},r_{1},A_{2})\cdot(A_{2},r_{2},A_{3})\cdot\cdots(A_{n},r_{n},A_{n+1})$ we define $\pi({P})=\pi({r_{1}})\cdots\pi({r_{n}})$, and $\overline{\pi}({P})=\overline{\pi}({r_{n}})\cdots\overline{\pi}({r_{1}})$.

Each accepting path $P$ in ${\sf graph}(G)$ corresponds to a word $\pi({P})\cdot\overline{\pi}({P})$ in $G$, and conversely, for any word $w\in G$, there exists an accepting path (not necessarily unique) in ${\sf graph}(G)$ corresponding to $w$.

Total order on paths.

We fix an arbitrary total order $<$ on $R$, and extend it to sequence of edges in $R^{*}$ as follows. Given paths $P_{1},P_{2}\in R^{*}$, we have $P_{1}<P_{2}$ iff

• •

$|P_{1}|<|P_{2}|$* (length of $P_{1}$ is smaller than length of $P_{2}$), or*

• •

$|P_{1}|=|P_{2}|$* and $P_{1}$ is smaller lexicographically than $P_{2}$.*

A path $P$ is called optimal if it is the minimal path from the first vertex of $P$ to the last vertex of $P$.

Test set for $G$.

Let $\Phi_{k}(G)$ be the set of words of $G$ corresponding to accepting paths of the form $P_{1}e_{1}P_{2}\cdots P_{n}e_{n}P_{n+1}$, $n\leq k$, with $P_{i}\in R^{*}$, $e_{i}\in R$, and where for $i\in\{{1,\dots,n+1}\}$, $P_{i}$ is optimal, and for $i\in\{{1,\dots,n}\}$, $P_{i}e_{i}$ is not optimal. By construction, a path in $\Phi_{k}(G)$ is uniquely determined (when it exists) by the choice of edges $e_{1},\dots,e_{n}$, as optimal paths between two vertices are unique. Therefore, $\Phi_{k}(G)$ contains at most $\sum_{i=0}^{k}|R|^{i}\leq 2|R|^{k}$ words.

We now show that $\Phi_{3}(G)$ is a test set for $G$ (which gives us the desired bound of the theorem: $2|R|^{k}$). Assume there exist two morphisms $f,g:\Sigma^{*}\to\Gamma^{*}$ such that ${f}_{|{\Phi_{3}(G)}}={g}_{|{\Phi_{3}(G)}}$ and there exists $w\in G$ such that $f(w)\neq g(w)$.

By assumption, $w$ does not belong to $\Phi_{3}(G)$, and must correspond to a path $P=P_{1}e_{1}P_{2}\cdots P_{n}e_{n}P_{n+1}$ for $n\geq 4$, such that for $i\in\{{1,\dots,n+1}\}$, $P_{i}$ is optimal, and $P_{i}e_{i}$ is not optimal. We pick $w$ having the property $f(w)\neq g(w)$ such that the path $P$ is the smallest possible (according to the order $<$ defined above).

The path $P$ can be written $P_{1}e_{1}P_{2}e_{2}P_{3}e_{3}P_{4}e_{4}W_{5}$ where for $i\in\{{1,2,3,4}\}$, $P_{i}$ is optimal, and $P_{i}e_{i}$ is not optimal ($W_{5}$* is not necessarily optimal). For $i\in\{{1,2,3}\}$, we define $Q_{i}$ to be the optimal path from the source of $P_{i}e_{i}$ to its target; hence $Q_{i}<P_{i}e_{i}$. Moreover, $Q_{4}$ is defined to be the optimal path from the source of $P_{4}e_{4}W_{5}$ to its target, with $Q_{4}<P_{4}e_{4}W_{5}$. Effectively, as shown in Figure 4, this defines $15$ paths that can be derived from $P$ by replacing subpaths by their corresponding optimal path ($Q_{1}$, $Q_{2}$, $Q_{3}$, $Q_{4}$).*

Let $P^{\prime}$ be one of those $15$ paths (where at least one subpath has been replaced by its optimal counterpart $Q_{1}$, $Q_{2}$, $Q_{3}$, or $Q_{4}$), and let $w^{\prime}\in G$ be the word corresponding to $P^{\prime}$. By construction of $P^{\prime}$, and by definition of the order $<$, we have $P^{\prime}<P$. Since we have chosen $P$ to be the smallest possible path such that $f$ and $g$ are not equal on the corresponding word, we deduce that $f(w^{\prime})=g(w^{\prime})$.

To conclude, we show that we obtain a contradiction, thanks to Lemma 1. For this, we construct two morphisms $f^{\prime},g^{\prime}:\Sigma_{4}\to\Gamma$ as follows ($i$* ranges over $\{{1,2,3,4}\}$ and $j$ over $\{{1,2,3}\}$):*

• •

$f^{\prime}(a_{i})=f(\pi({Q_{i}}))$,

• •

$f^{\prime}(\overline{a_{i}})=f(\overline{\pi}({Q_{i}}))$,

• •

$f^{\prime}(b_{j})=f(\pi({P_{j}e_{j}}))$,

• •

$f^{\prime}(\overline{b_{j}})=f(\overline{\pi}({P_{j}e_{j}}))$.

• •

$f^{\prime}(b_{4})=f(\pi({P_{4}e_{4}W_{5}}))$,

• •

$f^{\prime}(\overline{b_{4}})=f(\overline{\pi}({P_{4}e_{4}W_{5}}))$.

*The morphism $g^{\prime}$ is defined similarly, using $g$ instead of $f$. We can then verify that $f^{\prime}$ and $g^{\prime}$ coincide on $T_{4}$, but are not equal on the word $b_{4}\,b_{3}\,b_{2}\,b_{1}\,\overline{b_{1}}\,\overline{b_{2}}\,\overline{b_{3}}\,\overline{b_{4}}\in L_{4}$, thus contradicting Lemma 1. *

Appendix E Lower Bound Proof for the Tree Test Sets

See 2

Proof E.1**.**

Our proof is inspired by the lower bound proof for test sets of context-free languages [37, 38]. However, that lower bound did not work for context-free grammars with the extra assumption that all non-terminal symbols are starting symbols. Therefore, their proof cannot be applied for domains where all states are initial. Our contribution is a variant which shows that, even when all states of the domain are initial, the lower bound still holds and the minimal test-set has a cubic size.

For $n\geq 1$, we first define the domain $D_{n}=(\Sigma,Q,I=Q,\delta)$ containing linear trees (lists) of depth $1$ to $3$, and using $n$ different symbols of each level. Formally, we have (we use a functional notation for $\delta$, as $\delta$ is here deterministic):

• •

$\Sigma=\{{{A_{j}}^{({1})},{B_{j}}^{({1})},{F_{j}}^{({0})}\ |\ 1\leq j\leq n}\}$,

• •

$Q=\{{q_{2},q_{1},q_{0}}\}$,

• •

$\delta({A_{j}}^{({1})},q_{2})=(q_{1})$,

• •

$\delta({B_{j}}^{({1})},q_{1})=(q_{0})$,

• •

$\delta({F_{j}}^{({0})},q_{0})=()$.

$D_{n}$* recognizes $n^{3}+n^{2}+n$ trees. Our goal is to prove, by contradiction, that $D_{n}$ does not have a tree test set $T\subset D_{n}$ of size less than $n^{3}$. Let $t=A_{x}(B_{y}(F_{z}))\in D_{n}\setminus T$ for some arbitrary $x,y,z\in[1,n]$. $t$ exists when the size of $T$ is strictly less than $n^{3}$. We construct two 1STSs $\tau_{1}$ and $\tau_{2}$ such that ${{\llbracket}{\tau_{1}}{\rrbracket}}_{|{T}}={{\llbracket}{\tau_{2}}{\rrbracket}}_{|{T}}$ but ${\llbracket}{\tau_{1}}{\rrbracket}(t)\neq{\llbracket}{\tau_{2}}{\rrbracket}(t)$, contradicting the fact that $T$ is a tree test set.*

Let $\Gamma=\{{p,q}\}$ be an alphabet, and $\tau_{1}=(\Sigma,\Gamma,\delta_{1})$, $\tau_{2}=(\Sigma,\Gamma,\delta_{2})$, where

• •

$\delta_{1}(A_{j})=(\varepsilon,pq)$* if $j=x$,*

• •

$\delta_{1}(A_{j})=(\varepsilon,\varepsilon)$* otherwise,*

• •

$\delta_{1}(B_{j})=(\varepsilon,\varepsilon)$* if $j=y$,*

• •

$\delta_{1}(B_{j})=(p,q)$* otherwise,*

• •

$\delta_{1}(F_{j})=(qp)$* if $j=z$,*

• •

$\delta_{1}(F_{j})=(\varepsilon)$* otherwise,*

and

• •

$\delta_{2}(A_{j})=(pq,\varepsilon)$* if $j=x$,*

• •

$\delta_{2}(A_{j})=(\varepsilon,\varepsilon)$* otherwise,*

• •

$\delta_{2}(B_{j})=(\varepsilon,\varepsilon)$* if $j=y$,*

• •

$\delta_{2}(B_{j})=(p,q)$* otherwise,*

• •

$\delta_{2}(F_{j})=(qp)$* if $j=z$,*

• •

$\delta_{2}(F_{j})=(\varepsilon)$* otherwise.*

We can verify that ${{\llbracket}{\tau_{1}}{\rrbracket}}_{|{T}}={{\llbracket}{\tau_{2}}{\rrbracket}}_{|{T}}$, but $\tau_{1}(t)\neq\tau_{2}(t)$, as $\tau_{1}(t)=pqqp$ and $\tau_{2}(t)=qppq$.

We conclude that the only tree test set of $D_{n}$ is $D_{n}$ itself, which contains $n^{3}=(\frac{|\Sigma|}{3})^{3}$ words. Moreover, the (syntactic) size of $D_{n}$ is $O(n)$.

We note that the above transducers $\delta_{1}$ and $\delta_{2}$ have the same output on all $F_{k}$ and on all $B_{j}(F_{k})$. Therefore, even if we interactively ask questions as for Theorem 2, these questions will not be able to resolve the ambiguity which will appear only at the specific $A_{x}(B_{y}(F_{z}))$.

Appendix F Construction of $\Phi_{3}(G)$

To construct $\Phi_{3}(G)$ for a linear context-free grammar $G=(N,\Sigma,R,S)$, we precompute in time $O(|N|^{2}|R|)$, for each pair of vertices $(A,B)$, the optimal path from $A$ to $B$ in ${\sf graph}(G)$. Then for each possible choice of at most $3$ edges $e_{1}=(A_{1},r_{1},B_{1})$, …$e_{n}=(A_{n},r_{n},B_{n})$, with $0\leq n\leq 3$, we construct the path $P=P_{1}e_{1}\dots P_{n}e_{n}P_{n+1}$ where each $P_{i}$ is the optimal path from $A_{i-1}$ to $B_{i}$ (if it exists) with $A_{0}=S$ and $B_{n+1}=\bot$ by convention. We then add the word corresponding to $P$ to our result.

To conclude, since the length of each optimal path is bounded by $|N|$, we can construct $\Phi_{3}(G)$ in time $O(|N|\cdot|R|^{3})$.

Appendix G Proof of Running Time of Algorithm 3

See 2

Proof G.1**.**

The correctness and the polynomial running time of Algorithm 3 can be proved similarly to Algorithm 2.

Note that we can check whether the NFA $A$ recognizes only one word using the following polynomial time procedure. First, check if there exists a word $w$ recognized by $A$. If there is, pick a minimal word $w\in\A$, and compute the automaton $A\cap B$, where $B$ recognizes all words different than $w$ (the size of $B$ is roughly $|w|$). If the automaton $A\cap B$ is empty, then $A$ recognizes only $w$, otherwise $A$ recognizes more than one word.

The crucial part of Algorithm 3 is that it invokes the oracle $\tau_{u}$ at most $O(|D|)$ times. More precisely, we show that Algorithm 3 invokes $\tau_{u}$ at most $|Q|+3\sum_{(q,{f}^{({k})},(q_{1},\dots,q_{k})\in\delta}1+k$ times, which is $|Q|+3|D|$, and in $O(|D|)$.

Let $T_{\textit{inv}}\subseteq T$ be the set of trees for which Algorithm 3 invokes the oracle. Let $T_{\textit{min}}\subseteq T$ be the set of trees which are of the form ${\sf tree}(w_{A})$ for some $A\in G$ (where $w_{A}$ is the minimal word that can be produced from $A$, see Lemma 1). Note that, by construction of $G$, $|T_{\textit{min}}|\leq|Q|$.

Consider the set $T_{\textit{inv}}^{\prime}=T_{\textit{inv}}\setminus T_{\textit{min}}$. Let $W_{\textit{inv}}^{\prime}=\{{\tau_{\Sigma}(t)\ |\ t\in T_{\textit{inv}}^{\prime}}\}$ (or equivalently, $T_{\textit{inv}}^{\prime}=\{{{\sf tree}(w)\ |\ w\in W_{\textit{inv}}^{\prime}}\}$). We want to prove that $|T_{\textit{inv}}^{\prime}|\leq 3|D|$, thus implying that $|T_{\textit{inv}}|\leq 3|D|+|Q|$. Assume by contradiction $|T_{\textit{inv}}^{\prime}|>3|D|$.

Remember that, by construction of $T$, we have $W_{\textit{inv}}^{\prime}\subseteq\text{Lin}(G)$. For $w\in W_{\textit{inv}}$, consider the first non-epsilon rule in some derivation of $w$ in $\text{Lin}(G)$. By construction, $\text{Lin}(G)$ has at most $|D|$ rules.

Moreover, since $W_{\textit{inv}}$ contains strictly more than $3|D|$ words, $W_{\textit{inv}}$ must contain at least four words that share the same first non-epsilon rule in their derivation. Let $w_{a},w_{b},w_{c},w_{d}$ be four such words, and $t_{a},t_{b},t_{c},t_{d}$ their corresponding trees (with $t_{l}={\sf tree}(w_{l})$ for $l\in\{{a,b,c,d}\}$).

Without loss of generality, assume that Algorithm 3 invoked $\tau_{u}$ on the trees $t_{a}$, $t_{b}$, $t_{c}$, and $t_{d}$ in that order. By construction of $\text{Lin}(G)$, and from the fact that $w_{a}$, $w_{b}$, $w_{c}$, and $w_{d}$ share the first non-epsilon rule, we know there exists ${f}^{({k})}\in\Sigma$, $i\in\{{1,\dots,k}\}$, $t_{1},\dots,t_{i-1},t_{i+1},\dots,t_{k}\in T$, and $t_{i}^{a},t_{i}^{b},t_{i}^{c},t_{i}^{d}\in T$ such that:

[TABLE]

Said otherwise $t_{a}$, $t_{b}$, $t_{c}$, and $t_{d}$ only differ on their $i$th subtree. Let $x_{i}^{l}=\tau_{u}(t_{i}^{l})$ and $x_{l}=\tau_{u}(t_{l})$, for $l\in\{{a,b,c,d}\}$.

Given an assignment $\mu:\overline{\Sigma}\to\Gamma^{*}$, we define $u_{\mu}=\mu(f,0)\cdot\tau_{u}(t_{1})\cdot\mu(f,1)\cdots\mu(f,i-1)$, and $v_{\mu}=\mu(f,i+1)\cdots\tau_{u}(t_{k})\cdot\mu(f,k)$.

We consider several cases, all of them leading to a contradiction.

• •

There exist $x_{i}^{k},x_{i}^{l}\in\{x_{i}^{a},x_{i}^{b},x_{i}^{c}\}$ such that $x_{1}$ is not a prefix of $x_{2}$ and $x_{2}$ is not a prefix of $x_{1}$. Assume without loss of generality $x_{1}=x_{i}^{a}$ and $x_{2}=x_{i}^{b}$. Since Algorithm 3 invoked the oracle $\tau_{u}$ on the tree $t_{d}$, there are two assignments $\mu,\mu^{\prime}:\overline{\Sigma}\to\Gamma^{*}$ such that $u_{\mu}x_{i}^{d}v_{\mu}\in A$, $u_{\mu^{\prime}}x_{i}^{d}v_{\mu^{\prime}}\in A$, and $u_{\mu}x_{i}^{d}v_{\mu}\neq u_{\mu^{\prime}}x_{i}^{d}v_{\mu^{\prime}}$. Using the invariant of Algorithm 3 on trees $t_{a}$ and $t_{b}$, we know:

[TABLE]

Finally, since $x_{i}^{a}$ is not a prefix of $x_{i}^{b}$, and $x_{i}^{b}$ is not a prefix of $x_{i}^{a}$, we have ${\sf lcp}(x_{a},x_{b})=u_{\mu}\,{\sf lcp}(x_{i}^{a},x_{i}^{b})$ and ${\sf lcp}(x_{a},x_{b})=u_{\mu^{\prime}}\,{\sf lcp}(x_{i}^{a},x_{i}^{b})$. Thus, $u_{\mu}=u_{\mu^{\prime}}$ and we can deduce $v_{\mu}=v_{\mu^{\prime}}$. Thus, $u_{\mu}\,x_{i}^{d}\,v_{\mu}=u_{\mu^{\prime}}\,x_{i}^{d}\,v_{\mu^{\prime}}$, and we have a contradiction.

• •

Two elements of $\{x_{i}^{a},x_{i}^{b},x_{i}^{c}\}$ are equal. For instance if $x_{i}^{a}=x_{i}^{b}$, then Algorithm 3 could not have invoked the oracle $\tau_{u}$ on the tree $t_{b}$, as the only possible solution for $x_{b}$ is $x_{a}$.

• •

If we are not in one of the previous cases, we know that $x_{i}^{a},x_{i}^{b},x_{i}^{c}$ are of the form $x_{1}$, $x_{1}x_{2}$, $x_{1}x_{2}x_{3}$ (not necessarily in that order) for some $x_{1},x_{2},x_{3}\in\Gamma^{*}$, and $x_{2}\neq\varepsilon$ and $x_{3}\neq\varepsilon$. Consider the case where $x_{2}x_{3}\neq x_{3}x_{2}$.

Since Algorithm 3 invoked $\tau_{u}$ on the tree $t_{d}$, there are two assignments $\mu,\mu^{\prime}:\overline{\Sigma}\to\Gamma^{*}$ such that $u_{\mu}x_{i}^{d}v_{\mu}\in A$, $u_{\mu^{\prime}}x_{i}^{d}v_{\mu^{\prime}}\in A$, and $u_{\mu}x_{i}^{d}v_{\mu}\neq u_{\mu^{\prime}}x_{i}^{d}v_{\mu^{\prime}}$. Using the invariant of Algorithm 3, we know:

[TABLE]

Without loss of generality, assume that $u_{\mu^{\prime}}$ is a prefix of $u_{\mu}$ and $v_{\mu}$ is a suffix of $v_{\mu^{\prime}}$. So $u_{\mu}=u_{\mu^{\prime}}u^{\prime\prime}$ and $v_{\mu^{\prime}}=v^{\prime\prime}v_{\mu}$ for some $u^{\prime\prime},v^{\prime\prime}\in\Gamma^{*}$. Then, we have $u^{\prime\prime}\,x_{1}=x_{1}\,v^{\prime\prime}$, $u^{\prime\prime}\,x_{1}x_{2}=x_{1}x_{2}\,v^{\prime\prime}$, and $u^{\prime\prime}\,x_{1}x_{2}x_{3}=x_{1}x_{2}x_{3}\,v^{\prime\prime}$. We deduce, $x_{1}\,v^{\prime\prime}x_{2}=x_{1}x_{2}\,v^{\prime\prime}$, and $v^{\prime\prime}$ commutes with $x_{2}$.

Similarly, $v^{\prime\prime}$ commutes with $x_{2}x_{3}$. Assume by contradiction that $v^{\prime\prime}\neq\varepsilon$. Then, by Lemma 1, $x_{2}$ must commute with $x_{2}x_{3}$, and $x_{2}x_{2}x_{3}=x_{2}x_{3}x_{2}$, which implies $x_{2}x_{3}=x_{3}x_{2}$, and $x_{2}$ commutes with $x_{3}$, contradicting our assumption. This means that $v^{\prime\prime}=\varepsilon$, $v_{\mu}=v_{\mu^{\prime}}$, and $u_{\mu}=u_{\mu^{\prime}}$. We thus conclude $u_{\mu}x_{i}^{d}v_{\mu}=u_{\mu^{\prime}}x_{i}^{d}v_{\mu^{\prime}}$, contradicting the fact that Algorithm 3 invoked $\tau_{u}$ on tree $t_{d}$.

• •

The last case is when the $x_{i}^{a},x_{i}^{b},x_{i}^{c}$ are of the form $x_{1}$, $x_{1}x_{2}$, $x_{1}x_{2}x_{3}$ (not necessarily in that order) for some $x_{1},x_{2},x_{3}\in\Gamma^{*}$, with $x_{2}\neq\varepsilon$ and $x_{3}\neq\varepsilon$, and $x_{2}x_{3}=x_{3}x_{2}$.

Since Algorithm 3 invoked $\tau_{u}$ on the tree $t_{c}$, there are two assignments $\mu,\mu^{\prime}:\overline{\Sigma}\to\Gamma^{*}$ such that $u_{\mu}x_{i}^{c}v_{\mu}\in A$, $u_{\mu^{\prime}}x_{i}^{c}v_{\mu^{\prime}}\in A$, and $u_{\mu}x_{i}^{c}v_{\mu}\neq u_{\mu^{\prime}}x_{i}^{c}v_{\mu^{\prime}}$, where $A$ is the automaton constructed in Algorithm 3 at the iteration where $\tau_{u}(t_{c})$ was invoked.

Without loss of generality, assume that $u_{\mu^{\prime}}$ is a prefix of $u_{\mu}$ and $v_{\mu}$ is a suffix of $v_{\mu^{\prime}}$. So $u_{\mu}=u_{\mu^{\prime}}u^{\prime\prime}$ and $v_{\mu^{\prime}}=v^{\prime\prime}v_{\mu}$ for some $u^{\prime\prime},v^{\prime\prime}\in\Gamma^{*}$. We consider three subcases:

• –

Case $x_{i}^{c}=x_{1}x_{2}x_{3}$. Using the invariant of Algorithm 3 for trees $t_{a}$ and $t_{b}$, we know:

[TABLE]

Then, we have $u^{\prime\prime}\,x_{1}=x_{1}\,v^{\prime\prime}$, $u^{\prime\prime}\,x_{1}x_{2}=x_{1}x_{2}\,v^{\prime\prime}$. We deduce, $x_{1}\,v^{\prime\prime}x_{2}=x_{1}x_{2}\,v^{\prime\prime}$, and $v^{\prime\prime}$ commutes with $x_{2}$.

Thus, $x_{2}$ commutes both with $v^{\prime\prime}$ and $x_{3}$. By Lemma 1, $v^{\prime\prime}$ commutes with $x_{3}$. We deduce that $x_{1}x_{2}x_{3}v^{\prime\prime}=x_{1}v^{\prime\prime}x_{2}x_{3}=u^{\prime\prime}x_{1}x_{2}x_{3}$, and finally that $u_{\mu}x_{1}x_{2}x_{3}v_{\mu}=u_{\mu^{\prime}}x_{1}x_{2}x_{3}v_{\mu^{\prime}}$, contradicting $u_{\mu}x_{i}^{c}v_{\mu}\neq u_{\mu^{\prime}}x_{i}^{c}v_{\mu^{\prime}}$.

• –

Case $x_{i}^{c}=x_{1}x_{2}$. Using the invariant of Algorithm 3 for the trees $t_{a}$ and $t_{b}$, we know:

[TABLE]

Then, we have $u^{\prime\prime}\,x_{1}=x_{1}\,v^{\prime\prime}$, $u^{\prime\prime}\,x_{1}x_{2}x_{3}=x_{1}x_{2}x_{3}\,v^{\prime\prime}$. We deduce, $x_{1}\,v^{\prime\prime}x_{2}x_{3}=x_{1}x_{2}x_{3}\,v^{\prime\prime}$, and $v^{\prime\prime}$ commutes with $x_{2}x_{3}$.

Since $x_{2}x_{3}$ commutes both with $v^{\prime\prime}$ and $x_{2}$ (as $x_{2}$ and $x_{3}$ commute), we know by Lemma 1 that $x_{2}$ and $v^{\prime\prime}$ commute. We deduce that $x_{1}x_{2}v^{\prime\prime}=x_{1}v^{\prime\prime}x_{2}=u^{\prime\prime}x_{1}x_{2}$, and finally that $u_{\mu}x_{1}x_{2}v_{\mu}=u_{\mu^{\prime}}x_{1}x_{2}v_{\mu^{\prime}}$, contradicting $u_{\mu}x_{i}^{c}v_{\mu}\neq u_{\mu^{\prime}}x_{i}^{c}v_{\mu^{\prime}}$.

• –

Case $x_{i}^{c}=x_{1}$. Using the invariant of Algorithm 3 for the trees $t_{a}$ and $t_{b}$, we know:

[TABLE]

Then, we have $u^{\prime\prime}\,x_{1}x_{2}=x_{1}x_{2}\,v^{\prime\prime}$, $u^{\prime\prime}\,x_{1}x_{2}x_{3}=x_{1}x_{2}x_{3}\,v^{\prime\prime}$. We deduce, $x_{1}x_{2}\,v^{\prime\prime}x_{3}=x_{1}x_{2}x_{3}\,v^{\prime\prime}$, and $v^{\prime\prime}$ commutes with $x_{3}$.

Thus, $x_{3}$ commutes both with $v^{\prime\prime}$ and $x_{2}$. By Lemma 1, $v^{\prime\prime}$ commutes with $x_{2}$. Moreover, since $u^{\prime\prime}\,x_{1}x_{2}=x_{1}x_{2}\,v^{\prime\prime}$, we have $u^{\prime\prime}\,x_{1}x_{2}=x_{1}\,v^{\prime\prime}x_{2}$, and $u^{\prime\prime}\,x_{1}=x_{1}\,v^{\prime\prime}$. We conclude that $u_{\mu}x_{1}v_{\mu}=u_{\mu^{\prime}}x_{1}v_{\mu^{\prime}}$, contradicting $u_{\mu}x_{i}^{c}v_{\mu}\neq u_{\mu^{\prime}}x_{i}^{c}v_{\mu^{\prime}}$.

Appendix H Proof of Theorem 2

See 2

Proof H.1**.**

Let $D$ be a domain with the property above. First, remark that for some $s,u\in\Gamma^{*}$, if $t^{\prime}\in D^{\prime}$ and $t^{\prime}$ contains $v_{s}$, then all the trees obtained from $t^{\prime}$ by replacing $v_{s}$ by $v_{u}$ are also in $D^{\prime}$.

We build the linear tree test set $\text{T}^{\prime}$ as follows.

Let us associate to every symbol $f^{(k)}\in\Sigma$ and to every position in the arity $i\in[1,k]$ the tree $t_{i}$ as provided by the hypothesis. Let us take one of its $t^{\prime}_{i}\in D^{\prime}$ (denoted ${f}^{i}\!\!\left[{s}\right]$) such that $t^{\prime}_{i}$ contains at least one $v_{s}$ for some $s\in\Gamma^{*}$, the other $v$ being mapped to any other constant. For all other $u\in\Gamma^{*}$, remark that ${f}^{i}\!\!\left[{u}\right]\in D^{\prime}$.

Define $\text{T}^{\prime}$ containing all “default” trees and all their variations, changing one “#” to “?”:

[TABLE]

.

Note that $\text{T}^{\prime}$ is included in $D^{\prime}$, since the original tree was in $D^{\prime}$.

The size of the set $\text{T}^{\prime}$ is at most $2|\Sigma|\cdot A$. We will now prove that $\text{T}^{\prime}$ is a tree test set for $D^{\prime}$. Indeed, suppose that we have two transducers $\tau_{1}$, and $\tau_{2}$, and that they are equal on $\text{T}^{\prime}$. We will show the strong result that they have the same constants.

Let $f^{(k)}\in\Sigma$. Since ${f}^{i}\!\!\left[{\text{``\#''}}\right],{f}^{i}\!\!\left[{\text{``?''}}\right]\in\text{T}^{\prime}$ for $i\in[1,k]$, we can write

[TABLE]

which, for some $w_{i}$ and $z_{i}$ can be rewritten to:

[TABLE]

We apply Lemma 1 to conclude that $w_{i}=w^{\prime}_{i}$ and $z_{i}=z^{\prime}_{i}$, so we can remove the primes.

By hypothesis, we have that:

[TABLE]

which we can rewrite to:

[TABLE]

We also have $k$ other similar equalities by changing any of the “#” by a “?” at the same place in the two sides of the equation. Using Lemma 1, and by changing the first “#” to “?”, we obtain that $u_{0}w_{1}=u^{\prime}_{0}w_{1}$ so $u_{0}=u^{\prime}_{0}$. After simplifying the equations, it remains that:

[TABLE]

so we can continuously apply the lemma to obtain that $u_{1}=u^{\prime}_{1},\ldots u_{k}=u^{\prime}_{k}$. Hence $\text{T}^{\prime}$ is a tree test set of linear size.