WorksComputer Science
Learning of Tree Automata applied to Neural Language Acceptors
Abstract
We extract visibly pushdown grammars (VPGs) from neural language models in a fully black-box setting. Our work builds on the VPL* framework, which learns VPGs from recurrent networks by exploiting access to the target's internal state. First, we replace the white-box equivalence oracle with PAC sampling over trees. The resulting algorithm applies unchanged to transformer language models and, more generally, to any acceptor exposing only binary decisions. Second, we further observe that the original framework only ever queries the target on well-formed sequences that can be accepted by the most permissive VPG (called BParse) with the target's ranked alphabet. That is, VPL* is blind to the target's behavior outside BParse. Thus, we propose to sample trees directly instead of sequences and call the target with all the resulting sequences in order to provide an error estimate of how far the target deviates from being a VPG. Last but not least, we develop a learner that captures a tree automaton describing discovered behaviors of the target outside BParse, which results in a larger learnable space. We evaluate the approach on several cases, including transformers trained with Dyck grammars and synthetic targets designed to be outside BParse.
Introduction
The deployment of neural language models in domains where failures carry real consequences demands more than predictive accuracy, it requires the ability to inspect their behavior. A model that cannot be examined cannot be trusted in safety-critical settings, and post-hoc explanations of individual predictions do little to characterize a model as a whole. Grammatical inference explores another route: extract a symbolic surrogate model that captures the language the target model accepts, and reason about the surrogate. For models trained on inputs with no recursive structure, regular surrogates suffice, and a substantial body of work extracts deterministic finite automata from recurrent networks [2, 3, 4]. Many languages of practical interest; like arithmetic expressions, balanced parentheses or the syntax of programming languages; are not regular but exhibit nesting, and the visibly pushdown languages [5] are the natural class for them, strictly above regular.
The state of the art for active learning of visibly pushdown grammars (VPGs) from neural acceptors is the framework of [1], which operates over recurrent networks. Its equivalence oracle runs an search over the network’s internal state, presupposing both white-box access to the model and a recurrent architecture. Membership queries in their framework go through the construction of the most permissive VPG (called BParse) with the target’s ranked alphabet, called , which by definition restricts the learner’s view to well-matched inputs encoded as BParse-shaped trees. Thus, the extracted VPG describes the target only on this domain, being silent about whatever the model does on the rest of the input space.
Figure 1. The encoding of the Dyck-1 word . Each push letter becomes a binary node carrying its matched pop as the right child; each pop is a unary node; leaves stand for the empty word.
A complementary line of work learns VPGs directly from sample strings rather than from neural acceptors. [6] propose V-Star, which adapts Angluin’s L* to actively learn visibly pushdown grammars, inferring nesting structure from program inputs such as JSON, XML and S-expressions. Like VPL*, the model V-Star learns is always a visibly pushdown grammar, hence a VPL describing only well-matched inputs. Our learner instead extracts a tree automaton over the structured alphabet, a strictly more expressive object that can capture target behavior outside any VPL and produces witnesses when the target accepts ill-matched sequences that no VPG could.
This work makes three contributions over [1]. First, we replace their white-box equivalence oracle with PAC sampling over trees, yielding a fully black-box variant of VPL* that applies to any acceptor exposing only binary decisions. This allows applying the resulting learning algorithm to transformer language models, a family for which the A* oracle originally proposed in VPL* is not available. Besides, we drop the BParse gate on membership queries and sample trees directly from the structured alphabet’s language, and measure the errors incurred by VPL* when avoiding querying the target on non-well formed sequences. Finally, building on the previous step, we develop a learner that recovers a tree automaton that describes the target on all trees over the structured alphabet. When the target is not a VPG, the BParse-consistent observation table is projected to a VPG that agrees with the one produced by VPL*. We stress the fact that our implementation of VPL* is the first publicly available one.
Background
The tree encoding
Fix a structured alphabet partitioning into push, pop, and internal letters. The well-formed words are those in which every push has a matching pop in the standard bracket sense. Visibly pushdown languages [5] are the subsets of recognized by visibly pushdown grammars (VPGs), and we treat them throughout via their tree representation.
To each well-formed word, the BParse construction of [1] assigns a tree over the ranked alphabet with , , and . The encoding is defined inductively by , for , and for and . The map is a bijection between and its image , the BParse-shaped trees. The reverse direction extends to a map defined as the pre-order traversal of the tree’s internal-node labels, with leaves treated as . On the map agrees with ; on the rest of it is many-to-one. Figure 1 shows the encoding of the Dyck-1 word under , , .
Gated-VPL* with A*-based EQ
Given a binary acceptor that realizes some VPL , the VPL* framework of [1] learns a VPG for by lifting to a tree-language target through and running the tree-language extension of L* due to [7] and [8] (TL* ) on top. TL* maintains an observation table over trees and contexts, issues membership queries on individual trees, conjectures a deterministic tree automaton (DTA), and refines the conjecture on counterexamples returned by an equivalence query until convergence. Membership queries against are answered by
that is, trees outside the BParse image are gated to false before the target is consulted; the DTA produced by TL* is then post-processed into a VPG by the construction of [1]. We refer to this as gated-VPL*. Figure 2 shows the decision the gated membership oracle makes on each incoming tree. The equivalence query in their framework relies on search over the internal state of the RNN that realizes , which ties the algorithm to recurrent neural networks in a white-box setting.
Figure 2. The gated membership policy of VPL*. The oracle returns for BParse-shaped trees and false for everything else.
Analysis of shortcomings
Gated policy
The gated policy partitions into one region that the target sees and two that it does not. Made explicit:
Class A: . The tree is BParse-shaped; the target is consulted on .
Class B: but . The sequence is well-matched even though the tree is not BParse-shaped, and the BParse-shaped tree is a class-A tree that yields the same sequence.
Class C: and . The sequence is ill-matched; no BParse-shaped tree yields it.
Classes B and C are both gated to false by . For class B the gated false is a redundancy: the class-A tree already records , so the class-B label adds no information the observation table does not already have. Class C is where the gate hides information: the target may accept , and the gate suppresses that signal before the learner can react to it. The next sections lift the algorithm into a fully black-box regime and then recover the class-C signal in two complementary ways.
White-box equivalence
The framework of [1] relies on random sampling of sequences and search over the internal state of a recurrent network for equivalence queries, which constrains its application to white-box recurrent neural architectures.
In order to enable grammar inference on arbitrary acceptors, while providing statistical guarantees about the learned model, our first contribution is to replace that oracle with PAC-oracle over trees. Fix a distribution over and parameters . Let denote the lifted target evaluated by membership queries. Given a conjectured DTA , the oracle draws an i.i.d. sample of size
from at the -th equivalence query and returns the first on which , or equivalent if no disagreement is found. A standard analysis similar to [2] bounds the probability of returning equivalent on a DTA that disagrees with on more than an fraction of by over the entire equivalence-query history. The target is now an opaque function exposing only acceptance decisions; the rest of VPL* runs unchanged. The same machinery, applied with different choices of , drives the membership policies developed in the following sections. In what follows we assume uniform sampling over . The need for sampling trees rather than sequences is explained later in Section 5.2.
Leakage analysis on the gated learner
The gated MQ of Section 2.2 returns false on every tree outside , irrespective of what the target would say on the corresponding sequence. When the target is in fact a VPL this is the right choice; when it is not, the gate hides information. Our second contribution is to instrument the gated learner with a side oracle that quantifies what the gate hides, at the cost of one extra target query per class-C tree and no change to the membership semantics seen by TL*.
What the gate hides
Recall the partition of Trees() into classes A, B, C from § 3.1. On class A the gated MQ already issues and any information the target carries on enters the observation table. On class B the sequence is in but the tree is a class-A tree, so the gate’s false on class B suppresses a duplicate of an existing class-A row rather than hiding information. Class C is where the gate can lie. The sequence is outside , no class-A tree yields it, and the gate’s false can disagree with when the target accepts non-well-formed sequences. Concretely, a target that is not a VPL accepts some and the gate masks that fact. We call a class-C tree on which the target accepts the sequence a leakage witness: a sequence that the target accepts but no VPL with the same alphabet could.
The leakage detector
The detector is a side observer added to the gated MQ. When the gated MQ is called on a tree , the detector classifies and acts only on class C: it issues a single extra query and records the pair . The membership value returned to is unchanged — still false on class C — so the observation table, the DTA, and the extracted VPG are exactly what the gated algorithm of [1] would have produced. Figure 3 shows the augmented decision: the upper branch is the original , and the lower branch routes the class-A complement through an additional check that filters out class B before issuing the target query that drives the leakage signal.

Figure 3. Gated VPL* with the leakage detector. The main row is the original gated MQ followed by the leakage analysis (boxed in red): a class-B filter and a target query on class C that records a witness when the target accepts. The value returned to TL* is unchanged.
A probe is an instance of the lower branch’s target query. A witness is a probe the target accepted. The probe distribution is the distribution of class-C trees the gated learner happens to issue during its run; it is shaped by the learner’s counterexample stream, not by an external sampler. Two consequences follow. First, a witness is hard evidence: a sequence with . Any single such rules out the hypothesis that is a VPL of the given alphabet, since a VPL recognizes only subsets of . Second, the absence of witnesses is weaker evidence: the probes are not uniform over , so the witness rate measured on a run does not lift to a PAC bound on the target’s acceptance rate over the non-BParse population. A PAC-grounded estimate of that rate requires a separate stratified sampler that draws class-C trees from a fixed distribution independently of the learner’s trajectory. The detector itself is a witness collector, not a rate estimator.
Cost and integration
The detector adds one BParse check per non-class-A tree and one target query per class-C tree, both linear in . The count of gated queries is unaffected; the only extra cost shows up as additional target calls outside the MQ counter. The gated VPG is produced exactly as before; the detector emits a list of named witnesses, each tagged with a malformation type — an excess close, an excess open, or a more general non-bracket-balanced sequence — and the raw counts of probes and witnesses issued during the run. The two outputs are complementary: the VPG is the gated learner’s formal answer about the target on , and the witness list is a concrete refutation, when one exists, of the assumption that is a VPL at all.
The hybrid membership policy
The leakage detector of § 4 records the target’s behaviour outside but does not let the learner use it: every class-C tree is still gated to before sees the label. Our third contribution lifts the gate where it can be lifted safely. We define a new MQ policy that returns on class A (as the gate already does), on class B (the duplicate-suppression case), and on class C (where the gate previously suppressed information). The learner’s MQ stream now carries the class-C signal directly; the witness log of § 4 is still produced as a side effect. The hybrid membership oracle is
The class-A and class-B branches coincide with . The class-C branch is the new one: instead of returning before consulting the target, the oracle asks the target on the sequence and returns its answer. Figure 4 illustrates the decision: the upper branch is unchanged from Section 2.2, and the lower branch now splits on whether the sequence is in ; only class B falls through to , while class C feeds the target’s response back to .

Figure 4. The hybrid membership policy. Class A (top branch) behaves as in the original gated policy. Class B is forced to to suppress duplicates of class-A queries. Class C queries the target directly; an accepting target produces both a value fed back to and a leakage witness in the sense of § 4. The class-C rows (boxed in green) shape the DTA but are unreachable from the extracted VPG.
Raw gate
A natural alternative would be to drop the gate entirely and run on every tree. We call this the raw policy. The raw policy is what tempts the reader once the leakage detector has shown that class-C information is real; the issue is class B. Two class-B trees with carry identical labels under raw, so the observation table records the same target information twice. Worse, the same label is also carried by the class-A tree that yields the same sequence. The raw policy therefore floods the table with duplicates and changes the equivalence semantics on : states that the gated learner would have identified become distinguishable by class-B contexts whose only content is a class-A row in disguise. The hybrid policy keeps the gate on class B precisely to avoid this trap; the duplicate-suppression property of the gate is preserved exactly where it is needed. Figure 5 shows examples of class B and C trees.
Figure 5. Two malformed trees over the Dyck-1 alphabet, neither in . (a) Flipping the inner ’s children in the encoding of Figure 1: the right child should be the matched pop but is , so , yet is well-matched. The class-A tree already records , so the hybrid gate fires on this tree. (b) The root’s right child is , breaking BParse; the pre-order is unbalanced, so no class-A tree yields it, and the hybrid policy returns rather than .
Why sample trees and not sequences
Under the gated policy, the PAC oracle could in principle draw words from a sequence distribution and lift through ; this works because is a bijection between and , and the gate forces a label of false on every tree outside before the target is consulted. The hybrid policy breaks that argument. On class C the MQ reads the target on , and is many-to-one on : distinct trees with the same yield receive the same target label but are distinct rows in the observation table. There is no canonical inverse from sequences to trees outside the bijection’s domain , so the equivalence oracle has to sample trees directly. We adopt tree sampling throughout the paper, both to make the gated and hybrid algorithms run on a single sampling regime and to keep the comparison in § 6 on equal footing.
On-T equivalence with the gated learner
The hybrid MQ differs from the gated MQ only on class C. Two questions follow. Does the hybrid learner terminates? When it does, does its VPG agree with the gated VPG on ?
Termination is ensured by TL* [8] if the language of the target sequence acceptor is equal to , for some tree automaton acceptor over . Therefore, the class of sequence acceptors learned by the hybrid policy is larger than that of the gated policy.
Let us focus now on agreement on . The VPG produced by the hybrid policy, is obtained from the learned DTA via the same nta2vpg construction used in VPL*: read the BParse-pattern transitions off the DTA and emit one VPG rule per pattern. The construction depends only on the DTA’s behavior on . Empirically § 6: on every one of the 18 targets in the paper the VPGs result of the hybrid and gated learners agree on every BParse-shaped tree in a 2,000-tree sample. The DTA obtained by the former can nonetheless be much larger than the DTA of the gated one on a non-VPL target — up to 53 states and 259 NTA transitions on the bidirectional Dyck-1 transformer mol_bidir, and 21 states and 429 transitions on the synthetic all-accepting target, versus 2 and 2–3 for gated — but the extra states are unreachable from the VPG built by nta2vpg, because the wrapper constructs trees from sequences via and every lies in . The contribution of the hybrid policy is therefore to fold the leakage signal of § 4 into the learner’s normal trajectory, amplifying the witness collection without any new hyperparameter, while preserving the VPG on .
Experiments
We evaluate the leakage detector of § 4 and the hybrid policy of § 5 on three target families. E1 (§ 6.2) checks that on true VPL targets the hybrid pipeline produces no witnesses and reduces to the gated one. E2 (§ 6.3) uses two synthetic non-VPL targets to exhibit the witness signal and the on- equivalence between the obtained VPGs. E3 (§ 6.4) applies the same pipeline to a bidirectional transformer trained on Dyck from [9].
Setup
Let’s recall that a probe is a membership query on a class-C tree — a tree outside whose sequence is also outside . Every probe issues one target query , whose result both enters the observation table (under the hybrid policy) and is logged. A probe is a witness if the target accepts on its sequence form. Class-B queries are silent: they are forced to false by the gate and are not logged, since is already recorded by the class-A tree that yields the same sequence.
We compare two pipelines on every target: gated VPL* and hybrid VPL*. For each pipeline we record the DTA, the corresponding VPG (built by nta2vpg), the membership-query count, and the class-C probe and witness counts. To compare the two extracted grammars as languages we draw a fixed sample of 2,000 random trees (max depth 8) from and check, for each tree with , whether the gated () and hybrid () VPGs return the same acceptance bit on . The fraction of agreement is reported as on in each table below; 100% means the two grammars accept exactly the same BParse-shaped strings on the sample. All E1 and E2 runs use seed 71 and . E3 uses seed 42 and parameters , , due to the per-query cost of the transformer forward pass.
E1: VPG targets
The 15 visibly pushdown targets of [1] are each a VPL by construction, so on every class-C tree the target rejects the sequence. The hybrid MQ therefore returns false on every class-C tree, exactly as the gated MQ would, and the two trajectories coincide. Table 1 reports DTA, rule, MQ, probe, and witness counts. The values are identical between the gated and hybrid pipelines on every target; the table reports a single row per target. Across 24,228 class-C probes the target rejected every one. The hybrid policy collapses to the gated one as predicted; the entries of Table 1 are therefore also the gated baseline for E1.
| Target | States | Rules | MQs | Probes | Witnesses | on |
| L1 | 2 | 2 | 1,187 | 741 | 0 | 100% |
| L2 | 2 | 5 | 2,227 | 1,693 | 0 | 100% |
| L3 | 2 | 3 | 2,448 | 2,165 | 0 | 100% |
| L4 | 2 | 5 | 1,500 | 1,155 | 0 | 100% |
| L5 | 2 | 5 | 1,975 | 1,664 | 0 | 100% |
| L6 | 2 | 7 | 2,116 | 1,594 | 0 | 100% |
| L7 | 3 | 3 | 2,182 | 1,676 | 0 | 100% |
| L8 | 1 | 1 | 1,064 | 898 | 0 | 100% |
| L9 | 2 | 1 | 2,464 | 2,172 | 0 | 100% |
| L10 | 3 | 7 | 4,873 | 4,387 | 0 | 100% |
| L11 | 4 | 3 | 3,547 | 2,668 | 0 | 100% |
| L12 | 1 | 1 | 1,062 | 812 | 0 | 100% |
| L13 | 2 | 5 | 1,319 | 789 | 0 | 100% |
| L14 | 2 | 4 | 1,465 | 1,101 | 0 | 100% |
| L15 | 2 | 6 | 1,226 | 713 | 0 | 100% |
| Total | — | — | 30,655 | 24,228 | 0 | — |
Table 1. Gated and hybrid VPL* on the 15 visibly pushdown targets of [1]. State, rule, and MQ counts are identical between the two pipelines, and the extracted VPGs accept the same trees in on the 2,000-tree sample. No probe produced a witness.
E2: non-VPG targets
Two synthetic targets sit outside the VPL class in qualitatively different ways. Both use the alphabet , ; the first adds the internal symbol . The first target (E2, all-accepting) returns true on every , including every non-well-matched word. The second (E2b) accepts every well-matched Dyck-1 word and every sequence of the form for well-matched; its restriction to is exactly Dyck. Table 2 reports both pipelines on both targets.
| Target | Pol. | States | Rules | MQs | Probes | Witnesses | on |
| E2 (all-accepting) | 2 | 3 | 1,117 | 684 | 684 | — | |
| E2 (all-accepting) | 21 | 429 | 45,051 | 33,478 | 33,478 | 100% | |
| E2b (Dyck-1 with ) prefix) | 2 | 2 | 1,209 | 708 | 134 | — | |
| E2b (Dyck-1 with ) prefix) | 12 | 20 | 13,491 | 8,576 | 1,777 | 100% |
Table 2. Gated () versus hybrid () policies on the two synthetic non-VPG targets. The DTA of the hybrid policy grows substantially on both targets, but on the 2,000-tree sample the VPGs accept exactly the same BParse-shaped strings.
On both targets the hybrid pipeline finds many more witnesses than the gated detector. On the all-accepting target every class-C probe is a witness, and hybrid issues 33,478 such probes versus 684 under gated; on E2b the witnesses are concentrated in the excess close malformation class — 1,777 versus 134, with zero excess open witnesses in either policy, which is the structural fingerprint of the deviation. The hybrid DTAs are also much larger (21 states and 429 NTA transitions on E2, 12 and 20 on E2b) than the gated ones (2 and 3, and 2 and 2, respectively). The gap matters at the DTA level but not at the VPG level: the rightmost column shows that the two extracted grammars label every BParse-shaped tree in the sample identically, so the gated and hybrid VPGs are equivalent on the test dataset of well-formed strings. The extra hybrid states and rules are unreachable from the VPG built by nta2vpg, which constructs trees from sequences via and therefore only consults the class-A portion of the DTA.
E3: neural classifiers
We finally apply the pipeline to a bidirectional transformer classifier (mol_bidir) trained on by [9].2 The wrapper exposes the model as a binary acceptor of strings over . Table 3 reports the run under both policies.
| Model | Pol. | States | Rules | MQs | Probes | Witnesses | on |
| mol_bidir | 2 | 2 | 136 | 78 | 33 | — | |
| mol_bidir | 53 | 259 | 13,594 | 12,001 | 9,535 | 100% |
Table 3. Gated () versus hybrid () policies on [9]’s bidirectional transformer. The hybrid pipeline produces a substantially larger DTA and many more witnesses, yet the extracted VPGs accept exactly the same trees in on the sample.
The pipelines diverge sharply on what they see outside : the gated learner stops after 136 MQs and 78 class-C probes, of which 33 are accepted by the model; the hybrid learner uses those accepts as new table rows, its trajectory extends, and it ends up issuing 12,001 class-C probes (154× more than gated) with 9,535 witnesses (289× more, balanced between 4,464 excess-close and 5,071 excess-open accepted sequences). Every one of those extra accepts is invisible to the gated pipeline by construction — the gate suppresses the label and the gated trajectory never visits the corresponding region of Trees().
On- agreement evaluated empirically on the samples, showed that the VPL learned by both gated and hybrid policies, is the one of the grammar, in which it was trained. While the DTA obtained by the gated policy has 2 states, and nta2vpg resulted exactly in the grammar with 2 rules, the DTA produced by the hybrid policy has 53 states and the nta2vpg construction emits 259 rules. However, most rules are unreachable or duplicated.
Conclusions
We extended the VPL* framework of [1] along three axes. First, we replaced the white-box A* equivalence oracle with a PAC oracle that samples trees from Trees() and queries the target only through its binary output, so the pipeline applies to any acceptor exposing only binary decisions; in particular it applies to transformer acceptors, for which the original A* oracle is unavailable. Second, we added a leakage detector to the gated learner: it issues one extra target query per class-C tree and records witnesses — sequences outside that the target accepts, each of which refutes the hypothesis that the target is a VPL of the given alphabet — without changing the membership semantics seen by TL*. Third, we defined a hybrid membership policy that lifts the gate on class C and keeps it on class B, folding the leakage signal into the observation table.
The experiments leave three highlights:
Hybrid extends the space of learnable targets. On every target we tested, hybrid converged to a VPG; the gated pipeline is exactly hybrid restricted to the class-A and class-B branches, and inherits the same outcome on VPL targets while remaining silent about class C on non-VPL ones.
Gated and hybrid VPGs agree empirically. On every one of the 18 targets the two VPGs accepted the same BParse-shaped trees on the 2,000-tree comparison sample. We do not prove equivalence on ; the agreement reported is empirical and the question of whether it holds in general is left open.
The extracted VPG is not minimal. On non-VPL targets, the experiments showcased that the hybrid policy can result in DTAs larger than the gated one, and the nta2vpg projection inherits this increase in size, although most rules were useless. Minimizing the output is not straightforward: [10] show that, unlike regular languages, visibly pushdown languages in general admit no unique minimal automaton. Reducing the extracted grammar is therefore left for future work.
Acknowledgments Partially funded by Agencia Nacional de Investigación e Innovación (ANII), Uruguay, under grants FMV_1_2023_1_175864 and POS_NAC_2023_1_178663, and Programa de Desarrollo de las Ciencias Básicas (PEDECIBA), Uruguay.
References
- [1]Benoît Barbot, Benedikt Bollig, Alain Finkel, Serge Haddad, Igor Khmelnitsky, Martin Leucker, Daniel Neider, Rajarshi Roy, and Lina Ye. Extracting context-free grammars from recurrent neural networks using tree-automata learning and A* search. In Proceedings of the 15th International Conference on Grammatical Inference, volume 153 of Proceedings of Machine Learning Research, pages 113–129, 2021.
- [2]Dana Angluin. Learning regular sets from queries and counterexamples. Information and Computation, 75(2):87–106, 1987.
- [3]Franz Mayr and Sergio Yovine. Regular inference on artificial neural networks. In International Cross-Domain Conference for Machine Learning and Knowledge Extraction (CD-MAKE), Lecture Notes in Computer Science, pages 350–369, 2018.DOI
- [4]Gail Weiss, Yoav Goldberg, and Eran Yahav. Extracting automata from recurrent neural networks using queries and counterexamples. In Jennifer Dy and Andreas Krause, editors, Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pages 5247–5256, 2018.arxiv.org/abs/1711.09576
- [5]Rajeev Alur and P. Madhusudan. Visibly pushdown languages. In Symposium on the Theory of Computing, 2004.
- [6]Xiaodong Jia and Gang Tan. V-Star: Learning visibly pushdown grammars from program inputs, 2024.DOI
- [7]Yasubumi Sakakibara. Efficient learning of context-free grammars from positive structural examples. Information and Computation, 97(1):23–60, 1992.DOI
- [8]Frank Drewes and Johanna Högberg. Query learning of regular tree languages: How to avoid dead states. Theor. Comp. Sys., 40(2):163–185, February 2007.
- [9]Matías Molinolo De Ferrari. Exploring attention patterns and neural activations in transformer architectures for sequence classification in context-free grammars, 2024.
- [10]Rajeev Alur, Viraj Kumar, P. Madhusudan, and Mahesh Viswanathan. Congruences for visibly pushdown languages. In Automata, Languages and Programming, 32nd International Colloquium (ICALP), volume 3580 of Lecture Notes in Computer Science, pages 1102–1114, 2005.


