A syntax-semantics interface for Tree-Adjoining Grammars through Abstract Categorial Grammars

We present a model of the syntax-semantics interface for Tree-Adjoining Grammars (TAGs). It is based on the encoding of TAGs within the framework of Abstract Categorial Grammars (ACGs). This encoding relies on a functional interpretation of the substitution and adjunction operations of TAGs. In ACGs, the abstract terms representing derivation trees are full-fledged objects of the grammar. These terms are mapped onto logical formulas representing the semantic interpretation of natural language expressions that TAGs can analyze. Because of the reversibility properties of ACGs, this provides a way to parse and generate with the same TAG-encoded grammar. We propose several analyses, including for long-distance dependencies, quantification, control and raising verbs, and subordinate clauses. We also show how this encoding easily extends to other phenomena such as idioms or scope ambiguities. All the lexical data for theses modellings are provided and can be run with the ACG toolkit, a software package dedicated to the development of ACGs that can use these grammars both for parsing and generation.

natural languages. As the name indicates, the primary objects it considers are trees rather than strings, contrary to, for instance, contextfree grammars. As such, the object language a TAG generates is a tree language, the language of the derived trees. These trees result from the application of two operations, substitution and adjunction, to a set of generators: the elementary trees. The substitution operation consists in replacing one leaf of a tree by another tree, while the adjunction operation consists in inserting a tree into another one by replacing an internal node with a whole tree. A sequence of such operations and the elementary trees they operate on can be recorded as a derivation tree. Reading the leaves of the derived tree, or computing the yield, produces the associated generated string language.
The class of the generated string languages strictly includes the one generated by context-free grammars. This property, together with other ones such as the crucial polynomial parsing property, plays an important role in the characterization of the expressive power that natural language modelling requires.  proposed to call the class of languages (resp. grammars) necessary for describing natural languages the class of mildly context-sensitive languages or mCSL (resp. mildly context-sensitive grammars or mCSG). These formal and computational properties have been extensively studied 1 and provide TAG with appealing features for natural language processing. In addition to its formal properties, TAG has also been studied both from the perspective of fine-grained modellings of a wide range of linguistic phenomena, and from the perspective of large coverage. Large scale grammars have been developed for several languages, including English (XTAG Research Group 2001) and French (Abeillé 2002;Crabbé 2005;de La Clergerie 2005). In addition to these hand-crafted grammars, automatic extraction of TAGs has also been proposed (Xia et al. 2000;Xia 2001;Chen et al. 2006).
Another key feature that makes TAG relevant to natural language modelling lies in the capability of its elementary trees to locally specify (syntactic and semantic) dependencies between parts that can occur arbitrarily far from each other at the surface level at the end of a 1 See for instance Vijay-Shanker and Joshi (1985), Vijay-Shanker (1987), Weir (1988), Kuhlmann and Möhl (2007), Kanazawa (2008b), Kanazawa (2008a), and Kallmeyer (2010). [ 528 ] derivation. This property to locally state, within the elementary trees, dependency constraints is also known as the extended domain of locality (Joshi 1994). Thanks to the adjunction operation, a dependency described locally in an elementary tree can end as a long-distance dependency in the resulting derived tree. The relevant structure to store the relations between the elementary trees that are used in a derivation is then the derivation tree. This makes the latter structure appropriate to derive semantic representations for TAGs.
It was however noticed that derivation trees do not directly express the semantic dependencies, and that they seem to lack some structural information (Vijay-Shanker 1992; Candito and Kahane 1998). To overcome this problem, several approaches have been proposed. Some rely on extensions of the TAG formalism (Rambow et al. 1995(Rambow et al. , 2001; some others revisit the derivation tree definition in order to allow for recovering all the semantic dependency relations (Schabes and Shieber 1994;Kallmeyer 2002;. However, solutions to the problem strictly relying on derivation trees have also been proposed. They make use of unification Romero 2004, 2008), functional tree interpretation (Pogodalla 2004a(Pogodalla , 2009, synchronous grammars (Nesson and Shieber 2006;Nesson 2009), or tree transduction Kallmeyer and Kuhlmann 2012;Shieber 2014

TAG and Abstract Categorial Grammars: our approach
In this article, we elaborate on Pogodalla (2004aPogodalla ( , 2009 in order to propose a syntax-semantics interface and a semantic construction process for TAGs. We base our analysis on the framework of Abstract Categorial Grammars (ACGs: de Groote 2001). ACGs derive from typetheoretic grammars in the tradition of Lambek (1958), Curry (1961), and Montague (1973). They can be considered as a framework in which several grammatical formalisms may be encoded (de Groote and Pogodalla 2004), in particular TAGs (de Groote 2002). The definition of an ACG is based on a small set of mathematical primitives from type-theory, λ-calculus, and linear logic. These primitives combine via simple composition rules, offering ACGs a good flexibility. In particular, ACGs generate languages of linear λ-terms, which generalize both string and tree languages. [ 529 ] But ACGs are not restricted to languages of λ-terms encoding strings or trees. They can express logic-based semantic representation languages. And moving from one kind to another kind of language is realized by composing ACGs. We take advantage of the different composition modes to control the admissible derivation structures on the one hand, and to model the syntax-semantics interface on the other hand.
The core contribution of this article is to show that ACGs offer a suitable model of the syntax-semantics interface for TAG. By construction, this model is fully compositional and satisfies the homomorphic requirement between parse structures (terms representing derivation trees) and semantic terms. It relies on an encoding of TAGs into ACGs. For a given TAG G, with this encoding, we can construct and relate several ACGs that generate the same string language, derived tree language, and derivation tree language as G. By ACG composition, this encoding is the same as the one proposed by de Groote (2002) (that only addresses the syntactic encoding of TAG into ACG, not the syntaxsemantics interface), which ensures the correctness of the (syntactic) encoding. This encoding corresponds to the path with solid lines from TAG derivation trees to Strings in Figure 1. But we introduce an intermediate level, of generalized derivations, on which we base our syntax-semantics interface (the dashed lines in Figure 1). Doing so, we separate the level required for transferring the syntactic structures into semantics, and vice-versa, from the level that controls those structures so that only the ones that TAG considers to be admissible (i.e., TAG derivations) are kept. We show that this level allows us to account for the semantics of long-distance dependencies, quantification, separate modification without multiple adjunction, control verbs, raising verbs, etc. Moreover, this is done in a principled way, following the standard homomorphism between the syntactic and semantic categories of Montague (1973).
Contrary to Pogodalla (2004a) and Romero (2004, 2008), and similarly to synchronous TAG analyses (Nesson and Shieber 2006;Nesson 2009), the semantic modelling we propose does not rely on an intermediate underspecification language. We show instead that this is not required in order to model long-distance dependencies, raising verbs, or quantification. We also introduce and precisely describe the syntax-semantics modelling for adjectives (with- [ 530 ] Generalized derivations TAG derivation trees Derived trees

Strings
Logical formulas Figure 1: Overall architecture for the syntax-semantics interface out multiple adjunctions), control verbs, and subordinate clauses. We also discuss the encoding of features. While these modellings can essentially be rephrased in synchronous TAG (and vice-versa: 2 the solid lines of Figure 1 also correspond to the synchronous TAG architecture for the syntax-semantics interface), it is not the case for some other ones, and we show how the approach easily extends, without requiring the design of new parsing algorithms, to other phenomena such as idioms 3 or subordinate clauses, for which we propose a novel modelling. Other TAG extensions such as the cosubstitution operation proposed by Barker (2010) to model scope ambiguities also easily fall within the scope of our approach and can be given a type-raising account. In particular, this account exemplifies how to model the non-functional nature of the form-meaning relation. Finally, except for the type-raising account of quantification, the ACG model for the syntax-semantics interface of TAG that we propose belongs to the class of second-order ACGs. This class has the property that whatever the language we parse (strings, trees, or any kind of terms, such as first-order or higher-order logical formulas), parsing is polynomial. This parsing is implemented in the ACG toolkit. 4 Consequently, there is a parser that can actually recover the TAG derivation structure (if any) of some string, or of some derived tree, and interpret it as a logical formula, or that can actually recover the TAG derivation structure (if any) of some logical formula and interpret it as a derived tree or a string. The ACG framework is inherently reversible (Dymetman 1994), and parsing and generation of second-order ACGs are performed in polynomial time, including for the modellings that go beyond TAG (except the type-raising account of quantification), without having to design new parsers. Note, however, that we do not yet address the problem of logical-form equivalence (Shieber 1993) which states that, even if two formulas are logically equivalent, it might be possible to recover a derivation structure for one but not for the other.
We also validated the modellings and the lexicons we provide in this article, both for parsing and generation, by implementing in the ACG toolkit all the examples of this article. This results in a toy grammar (corresponding to about forty elementary trees) exemplifying the analyses of various linguistic phenomena presented in the article. 5 An extension to a real-size TAG grammar for French is ongoing.

Organisation of the article
In Section 2, we show a functional interpretation of the substitution and adjunction operations. We review the definitions that are necessary to model strings and trees as λ-terms (Section 2.2) and we use them to model the elementary trees of TAG. Section 3 reviews the definitions that are specific to ACGs. We show their main composition models and present their formal properties.
In Section 4, we introduce the ACGs that are necessary for the encoding of the syntax-semantics interface: the ACG relating strings and derived trees in Section 4.1; the ACG relating derived trees and generalized derivation trees in Section 4.2 and Section 4.3. We show that these generalized derivations over-generate with respect to TAG derivation trees: the full TAG encoding is not yet completed, but we already have all the necessary parts to implement the syntax-semantics interface.
Section 5 is devoted to the model of the syntax-semantics interface we propose. We first define the semantic representation language in Section 5.1. Then, in Section 5.2, we show how to interpret the 5 The example files are available at https://hal.inria.fr/ hal-01242154/file/acg-examples.zip. The script file illustrates the terms we use in this article and refers in comments to the relevant sections, equations, and term names.
[ 532 ] generalized derivations as semantic terms and we provide several classical examples.
In Section 6 we complete the faithful TAG encoding by controlling the generalized derivations so that only TAG derivations are accepted. The correctness of the encoding is ensured by recovering, by ACG composition, de Groote's (2002) encoding. Then, again by ACG composition, we directly obtain a syntax-semantics interface for TAG. Because ACGs do not make use of features, we explain how we model the adjunction constraints induced by feature structures in TAG (Section 7).
In Section 8, we take advantage of the architecture we propose and give examples of modellings that this framework offers and that are beyond TAG. We finally discuss the relation of our approach to the syntax-semantics interface for TAG with other ones, in particular the ones using synchronous grammars or feature unification (Section 9).

Adjunction and substitution
A TAG consists of a finite set of elementary trees whose nodes are labelled by terminal and non-terminal symbols. Nodes labelled with terminals can only be leaves. Elementary trees are divided into initial and auxiliary trees. Figure 2 exemplifies such trees. Substituting α John in α sleeps consists in replacing a leaf of α sleeps labelled with a nonterminal symbol NP with the tree α John whose root node is labelled by NP as well. 6 Figure 3(a) shows an example of such a substitution (at Gorn address 1) and of its result. The corresponding derivation tree recording the substitution is represented in Figure 3 [ 533 ] the Gorn address labels the edge between the two nodes, each of them being labelled by the name of the trees. Only initial trees, that possibly underwent some substitution or adjunction operations, can substitute into a leaf. The adjunction of β seemingly into α sleeps consists in inserting the tree β seemingly at the VP node of α sleeps : the subtree of α sleeps rooted at its VP node is first removed then substituted to the VP foot node of β seemingly (the leaf with the same label as the root and marked with * ). The whole resulting tree is then plugged again at the VP node of α sleeps , as Figure 4(a) shows. The associated derivation tree of Figure 4(b) records the adjunction with a dotted edge. Only auxiliary trees, that possibly underwent some substitution or adjunction operations, can adjoin into another tree. Figure 5 shows a TAG analysis of John seemingly sleeps, which involves both operations, and the associated derivation tree.

TAG elementary trees as functions
We now present the two operations of adjunction and substitution using a functional interpretation of the elementary trees. We use the Definition 1 (Types). Let A be a set of atomic types. The set (A) of implicative types built upon A is defined with the following grammar: The set of linear implicative types built upon A is defined with the following grammar: Definition 2 (Higher-order signatures). A higher-order signature Σ is a triple Σ = 〈A, C, τ〉 where: • A is a finite set of atomic types; • C is a finite set of constants; • τ : C → (A) is a function assigning types to constants.
A higher-order signature Σ = 〈A, C, τ〉 is linear if the codomain of τ is o (A).
Definition 3 (λ-Terms). Let X be a countably infinite set of λvariables. The set Λ(Σ) of λ-terms built upon a higher-order signature Σ = 〈A, C, τ〉 is inductively defined as follows: • if c ∈ C then c ∈ Λ(Σ); • if x ∈ X then x ∈ Λ(Σ); • if x ∈ X and t ∈ Λ(Σ) and x occurs free in t exactly once, then • if x ∈ X and t ∈ Λ(Σ), then λx.t ∈ Λ(Σ); Note there is a linear λ-abstraction (denoted by λ o ) and a (usual) intuitionistic λ-abstraction (denoted by λ). A variable that is bound by λ o occurs exactly once in the body of the abstraction, whereas it can occur zero, one, or any number of times when it is bound by λ. This distinction is important when discussing the complexity of parsing with ACGs.
Definition 4 (Typing judgment). Given a higher-order signature Σ, the typing rules are given with an inference system whose judgments are of the form: Γ; ∆ ⊢ Σ t : α where: • Γ is a finite set of non-linear variable typing declarations of the form x : β where x is a variable and β is a type; • ∆ is a finite multi-set of linear variable typing declarations of the form x : β where x is a variable and β is a type. In order to distinguish the elements of the typing declaration, we always use variables with different names.
Both Γ and ∆ may be empty. If both of them are empty, we usually write t : α (t is of type α) instead of ⊢ Σ t : α. Moreover, we drop the Σ subscript when the context permits. Table 1 gives the typing rules: constant introduction, variable introduction (linear and non-linear), linear abstraction and linear application, (non-linear) abstraction and (non-linear) application, in this order.
The fact that Γ is a set and ∆ is a multi-set corresponds to implicitly allowing for the structural rules of contraction and weakening for the non-linear context, and disallowing them on the linear context. 7 Remark 1. From a logical point of view, the theorems that can be proved using only the non-linear or the linar context are different. For instance, if c : α → α → β and d : α ⊸ α ⊸ β are constants of Σ, x : α; ⊢ c x x : β is derivable as the following derivation shows: Remark 2. The linear context of the second premise in the non-linear application rule (Γ; ⊢ Σ u : α) is empty. This is required in order to avoid duplicating or erasing linear variables by non-linear application to a linear variable. Otherwise we could have derivations such as: . . .
Then we have that y : α belongs to the linear context, but (λx.c x x) y reduces to c y y where y is duplicated.
Definition 5 (Linear and almost linear λ-terms). A term without any λs, where each λ o binds exactly one variable, and where no subterm contains more than one free occurrence of the same variable is a linear λ-term, otherwise it is non-linear.
A term where each λ o binds exactly one variable, where each λ binds at least one variable, and no subterm contains more than one free occurrence of the same variable, except if the variable has an atomic type, is an almost linear λ-term.
The notion of linearity and almost linearity are important with respect to the tractability and the computational complexity of the parsing algorithms, because they allow for characterising the set of almost linear λ-terms that are β-equivalent to some given almost linear term (Kanazawa 2017(Kanazawa , p. 1120. Definition 6 (Order). The order ord(τ) of a type τ ∈ (A) is inductively defined as: By extension, the order of a term is the order of its type.
Remark 3. Second-order terms (i.e., terms whose order is 2) play an important role in our TAG encoding, and more generally for the expressive power of ACGs. A second-order term has type a 1 ⊸ a 2 . . . ⊸ a n ⊸ a where a, a 1 , . . . , a n are atomic types. If a signature Σ contains only first-order and second-order constants, an easy induction shows that ground terms (i.e., terms with no free variable) of atomic types in Λ(Σ) do not contain any variable (bound or free) at all. In particular, they cannot have terms of the form λ o x.u or λx.u as sub-terms.
We now assume the single atomic type T of trees and constants of this type (in Section 2.3 we make explicit how to systematically encode trees into λ-terms).

2.2.1
Substitution as function application The ability for the tree of Figure 6(a) to accept a substitution at its NP node allows it to be considered as a function that takes a tree as argument and replaces the NP node by this argument. Hence we can represent it as the function γ ′ sleeps shown in Figure 6(b) with γ ′ sleeps : T ⊸ T . A tree where no substitution can occur can be represented as γ John : T (see Figure 6(c)). Applying the function γ ′ sleeps to the simple tree γ John of Figure 6(c) and performing β-reduction gives the expected result as (1) shows.
Note that despite the derived tree for John sleeps having a root labelled by S and the elementary tree for John having a root labelled by NP, they are represented by the terms γ ′ sleeps γ John and γ John which both have type T . The issue of recording the distinction is addressed in Section 4.3.

2.2.2
Adjunction as function application In order to deal with the adjunction operation, we first observe what happens to the auxiliary tree β seemingly in Figure 4 (p. 534): a subtree of the tree it is adjoined to (the VP rooted subtree of α sleeps ) is substituted at the VP * foot node of β seemingly . This means that the auxiliary tree also behaves as a function from trees to trees and can be represented as in Figure 7(a) with γ ′ seemingly : T ⊸ T . Then, a tree with an adjunction site can be represented by a term such as γ ′′ sleeps : (T ⊸ T ) ⊸ T in Figure 7(b). Note the higher-order type of γ ′′ sleeps . In order to model the adjunction, we then apply γ ′′ sleeps to γ ′ seemingly and perform β-reductions as (2) shows.
(a) Function from trees to trees We are now (almost) in a position to define the function standing for the elementary tree representing the intransitive verb sleeps in its canonical form as in Figure 8 with γ ′′′ sleeps : (T ⊸ T ) ⊸ T ⊸ T . Such a term can be used to represent the TAG analysis of John seemingly sleeps shown in Figure 5 with the β-reduction of γ ′′′ sleeps γ ′ seemingly γ John shown in (3).
Remark 4 (No adjunction). Typing γ ′′′ sleeps with (T ⊸ T ) ⊸ T ⊸ T makes it require an adjunction (the first (T ⊸ T ) argument) to return a [ 540 ] γ ′′′ sleeps = λ o a s. plain tree term of type T . But of course, we also want to use this term in case no adjunction in a TAG analysis would occur, as in John sleeps. We make use of a fake adjunction, applying γ ′′′ sleeps to the identity function I = λ o x.x : T ⊸ T . 8 Then (4) holds.
Finally, we also have to model the possible adjunction on the S node of α sleeps . So the corresponding term γ sleeps has type (T ⊸ T ) ⊸ (T ⊸ T ) ⊸ T ⊸ T where the first argument stands for the auxiliary tree to be adjoined at the S node, the second argument stands for the auxiliary tree to be adjoined at the VP node, and the third argument stands for the tree to be substituted at the NP node as Figure 9 shows. 9 Remark 5 (Multiple adjunction). Following Vijay-Shanker (1987), the typing we provide prevents two adjunctions from occurring at the same node in the same elementary tree. We discuss this difference with the multiple-adjunction approach of Schabes and Shieber (1994) in Section 5. Accordingly, an auxiliary tree should typically also allow for adjunction at its root. So instead of using γ ′ seemingly : T ⊸ T , we use the terms defined in Figure 10 in order to analyze sentences 8 This idea is present in the seminal work using ACGs (de Groote 2002;Pogodalla 2004a), but also in the synchronous approach (Shieber 2004) and in Shieber (2014, in the notion of vestigial auxiliary tree. 9 We could also allow adjunctions to the V node in a similar way. But we do not use examples of such adjunctions, and, for the sake of conciseness, we keep the type as small as required by the examples. [ 541 ]    Figure 11 with the term γ sleeps I (γ seemingly (γ usually I)) γ John . 10

Trees and strings as λ-terms
So far, we did not make explicit how to represent strings and trees as λ-terms. In particular, we did not explain how strings can combine and how the parent-child relation can be represented. While this is 10 Although λ o v.γ ′ usually (γ ′ seemingly v) = γ seemingly (γ usually I), introducing γ seemingly and γ usually with this more complex types is important because, as we will see in Section 6, at the most abstract level, we want terms without any free or bound variable to represent derivations (see Remark 3).
[ 542 ] quite standard, and because we use this encoding to implement the example grammars using the ACG toolkit, this section describes how it can be done.

2.3.1
Encoding strings We encode strings over an alphabet C using the following higher-order signature Σ C strings = 〈A σ , C, τ σ 〉 where: • A σ = {o} contains a unique atomic type o; • τ σ is the constant function that maps any constant to the type σ, the string type, defined as (o ⊸ o). Note it is not an atomic type.
We use the notation ∆ = to introduce terms or types that are defined using the atomic types and the constants of a signature, but are not atomic types nor constants of this signature. So σ ∆ = (o ⊸ o). We also define two other terms: function composition, used with an infix notation) to represent concatenation; x (the identity function) to represent the empty string.
It is easy to check that + is associative and that ε is a neutral element for +. Remark 6. If a and b are two strings, a+ b = λ o z.a (b z). In this article, we usually do not unfold the definition of + and we use the notation x 1 + . . . + x n to represent the string λ o z.x 1 (. . . (x n z) . . .).

Encoding trees
Trees were originally defined in TAG using a mapping from positions (or Gorn addresses) to labels, elements of a vocabulary (Joshi et al. 1975). Hence, the same node label could be used to represent nodes of different arity. For instance, in Figure 2(a) (p. 533), the VP node has arity 1 whereas the VP node of Figure 2(c) has arity 2. We prefer to represent trees as terms over a ranked alphabet as in Shieber (2004) and Comon et al. (2007) in order to make the encoding of trees as λ-terms easier. So we use the notation X n with n the arity of the symbol X n . It allows us to distinguish two nodes with n and m (n ̸ = m) children that would be mapped to the same label X by using the different symbols X n and X m . As terminal symbols can [ 543 ] only occur as leaves, they always have arity 0, so we do not use any subscript for them.
In order to encode the trees defined over a ranked alphabet a = ( , arity), where arity is a mapping from to N, we use the following higher-order signature Σ a trees = 〈A T , , τ a T 〉 where: • A T = {T } contains a unique atomic type T , the type of trees; • τ a T is a function that maps any constant X such that arity(X ) = n to the type T ⊸ · · · ⊸ T n times ⊸ T . If arity(X ) = 0, then τ a T (X ) = T .
For instance, the TAG elementary trees δ anchor 11 of our running examples can be modelled as the functions (or terms) γ anchor built on the signature Σ trees as Table 2 shows. 12 Then (5) shows that
(5) γ 5 = γ sleeps I (γ seemingly I) γ John → β S 2 (NP 1 John) (VP 2 (Adv 1 seemingly) (VP 1 (V 1 sleeps))) We now want to relate the tree that is represented by the term γ sleeps I (γ seemingly I) γ John : T to the string John seemingly sleeps that is represented by the term John + seemingly + sleeps : σ. We do this in Section 4, using an interpretation of the former as defined by an ACG.

abstract categorial grammars
Grammars can be considered as a device to relate concrete objects to hidden underlying structures. For instance, context-free grammars relate strings to syntactic trees, and TAGs relate derived trees to derivation trees. However, in both cases, the underlying structure is not a first-class citizen of the formalism. ACGs take another perspective and provide the user a direct way to define the parse structures of the grammar, the abstract language. Such structures are later on interpreted by a morphism, the lexicon, to get the concrete object language. The process of recovering an abstract structure from an object term is called ACG parsing and consists in inverting the lexicon. In this perspective, derivation trees of TAGs are represented as terms of an abstract language, while derived trees and yields are represented by terms of some other object languages: an object language of trees in the first case and an object language of strings in the second. We also use a logical language as the object language to express the semantic representations.
For the sake of self-containedness, we first review the definitions of de Groote (2001).
The lexicon is the interpreting device of ACGs.
Given an ACG name = 〈Σ 1 , Σ 2 , name , S〉, instead of using name (α) = β (resp. name (t) = u) in order to express that the interpretation of the type α is the type β (resp. the interpretation of the term t is the term u), we use the following notational variants: name (α) = β and α name β (resp. name (t) = u and t name u). The subscript may be omitted if clear from the context. Definition 9 (Abstract and object languages). Given an ACG , the abstract language is defined by The object language is defined by In this article, we consider object languages such as strings or logical formulas, and abstract languages such as derivation trees. Some languages, such as the language of derived trees, will be considered sometimes as object languages, sometimes as abstract languages.
Parsing with an ACG any term u that is built over the object vocabulary of amounts to finding the abstract terms t ∈ ( ) such that u = (t). In other words, ACG parsing is morphism inversion.

ACG composition
The lexicon defines the way structures are interpreted. It plays a crucial role in our proposal in two different ways. First, two interpretations may share the same abstract vocabulary, hence mapping a single structure into two different ones. For instance, the structure representing the derivations may be mapped both into a surface form and a semantic form. This composition is illustrated by derived trees and sem. sharing the Σ derivations vocabulary in Figure 12. It corresponds to the core model of the syntax-semantics interface as proposed in ACGs (de Groote 2001, Section 2.3), but also to the one proposed in synchronous TAG. It allows us to relate the derived trees and the semantic expressions that have the same derivation structures. We use this in Section 5 as our model of the syntax-semantics interface for TAG.

Figure 12: ACG composition modes
Second, the result of a first interpretation can itself be interpreted by a second lexicon when the object vocabulary of the first interpretation is the abstract vocabulary of the second one. This composition, illustrated by the yield • derived trees composition in Figure 12, provides modularity. It also allows one to control admissible intermediate structures. For instance, the abstract language of yield may contain too many structures. If the object language of derived trees is a strict subset of this abstract language, then the object language of yield • derived trees is a subset of the object language of yield . We take advantage of this property in Section 4.3 to enforce the matching between node labels in substitution and adjunction operations, and to further restrict the set of derivations to only TAG derivations in Section 6. This ACG composition corresponds to the typical ACG way to control admissible parse structures.

Formal properties of ACGs
In this section, we review the main properties of ACGs and mention the relevant references. Two parameters are useful to define a hierarchy of ACGs: the order and the complexity of an ACG.
Definition 10 (Order and complexity of an ACG; ACG hierarchy). The order of an ACG is the maximum of the orders of its abstract constants. The complexity of an ACG is the maximum of the orders of the realizations of its atomic types.
We call second-order ACGs the set of ACGs whose order is at most 2.
ACG (n,m) denotes the set of ACGs whose order is at most n and whose complexity is at most m.
For instance, in Figure 12, yield is a second-order ACG (because all the constants of Σ trees are of type T ⊸ · · · ⊸ T with T atomic, hence are at most second-order). On the other hand, Σ derivations is third-order (it contains terms such as c seemingly : (VP ⊸ VP) ⊸ VP ⊸ VP, where NP and VP are atomic, that are third-order; see Section 4). Hence derived trees is third-order as well.
The class of second-order ACGs is of particular interest because of its polynomial parsing property (Salvati 2005). When considering strings as the object language, the generated languages coincide with multiple context-free languages (Salvati 2006). When considering trees, the generated languages coincide with the tree languages generated by hyperedge replacement grammars (Kanazawa 2009). A further refinement on the ACG hierarchy provides a fine-grained correspondence with regular (string or tree) languages, context-free string and linear context-free tree languages, or well-nested multiple context-free languages (string), in particular tree-adjoining languages. For second-order ACGs, parsing algorithms and optimization techniques are grounded on well established fields such as type-theory and Datalog. Kanazawa (2007) showed how parsing of second-order ACGs reduces to Datalog querying, offering a general method for getting efficient tabular parsing algorithms (Kanazawa 2017). This parsing method applies whatever the object language: representing [ 548 ] String language Tree language ACG (1,n) finite finite ACG (2,1) regular regular ACG (2,2) context-free linear context-free ACG (2,3) non-duplicating macro ⊂ 1-visit attribute grammar well-nested multiple context-free ACG (2,4) mildly context-sensitive tree-generating (multiple context-free) hyperedge replacement gram. Table 3: The hierarchy of second-order ACGs strings, trees, and also any kind of (almost linear) λ-terms. When the object language consists of logical formulas, the latter can then be parsed as well, and the resulting parse structures can further be interpreted (e.g., as strings) to implement surface realization (Kanazawa 2007). This also allows for deriving algorithms with specific properties such as prefix-correctness in a general way. 13 The computational properties of lexicon inversion for ACGs have been studied for different classes of λ-terms. 14 It is worth noting that, as far as second-order ACGs are concerned, whatever the form of the semantic λ-term, lexicon inversion is decidable (Salvati 2010), even with replication and vacuous abstraction of variables, though with a high computational complexity. From a theoretical point of view, this corresponds to removing any kind of semantic monotonicity requirement for generation (Shieber 1988;Shieber et al. 1989) in a very general setting. 15 The examples we present in this article use only almost linear semantic terms. This allows us to run them in the ACG toolkit. The latter implements the method of parsing by reduction to Datalog, and allows 13 For a n 6 prefix-correct Earley recognizer for TAGs, see Kanazawa (2008b). 14 See for instance Kanazawa (2017), Bourreau and Salvati (2011), and Bourreau (2012) for the linear, almost linear, and almost affine cases.
15 In its strongest form, this requirement corresponds to having lexicalized semantic recipes (i.e., where at least one constant appears and no deletion is allowed). Linear and almost linear pure terms (i.e., where no constant occurs) are already dealt with in the Datalog reduction. Allowing deletion leads to more challenging issues. It is used, for instance, for the modelling of ellipsis (Kobele 2007;Bourreau 2012Bourreau , 2013 or for providing intensional semantics to intensioninsensitive words (de Groote and Kanazawa 2013).
[ 549 ] us to parse strings, trees, and logical formulas using the grammars we propose. Large scale tests of the software are however ongoing work, and a quantitative evaluation is beyond the scope of this article.
Parsing with ACGs whose order is strictly greater than 2 is equivalent (Salvati 2005) to the decidability of the Multiplicative Exponential fragment of Linear Logic (MELL: Girard 1987). 16 De Groote (2015) shows a reduction of ACG parsing of higher-order ACGs to linear logic programming. It is of course trivially (by linearity) decidable for ACGs where the interpretation of abstract constants always introduces a constant of the object language. But even in this case, thirdorder ACGs can generate languages that are NP-complete (Yoshinaka and Kanazawa 2005;Salvati 2006). For higher-order ACGs, the ACG toolkit implements abstract term interpretation, but no parsing. 4 relating generalized derivations, tag derived trees, and strings with abstract categorial grammars From now on, we assume a TAG G = (I, A) where I is the set of initial trees and A the set of auxiliary trees. The labels of the trees in I ∪ A range over the alphabet V 0 , and C ⊂ V 0 is the terminal alphabet. V is the set of symbols of V 0 disambiguated by subscripting them with their arity (except for terminal symbols of arity 0), and V is the associated ranked alphabet.

Derived trees and strings
In the constructions of Section 2.3, we introduced two higher-order signatures: Σ strings = Σ C strings and Σ trees = Σ V trees . We can now relate terms built on them using an ACG yield = 〈Σ trees , Σ strings , yield , T 〉 by specifying yield as follows: • yield (T ) = σ (a tree is interpreted as a string); . . x n .x 1 + · · · + x n (a tree labelled by a non-terminal symbol is interpreted by the function that concatenates the interpretation of its children); • for a ∈ C, yield (a) = a (a terminal symbol is interpreted by the same symbol as a string). 16 It has recently been proved to be decidable (Bimbó 2015).

Derivation trees and derived trees
In this section, we illustrate how to introduce more control on the accepted structures. Note indeed that according to the definition of yield , whatever is a closed term of type T belongs to its abstract language. For instance, γ 13 = γ seemingly I γ John is a well-typed term of type T corresponding to the tree of Figure 13 as (9) shows. Consequently, its interpretation seemingly + John belongs to the object language. In order to avoid such terms belonging to the language we are interested in, we provide another ACG, derived trees , such that its object language is a strict subset of ( yield ) (see Figure 12 p. 547). Consequently, the object language of yield • derived trees is a subset (strict in this case, as expected) of ( yield ). derived trees is defined as derived trees = 〈Σ derivations , Σ trees , derived trees , S〉.

4.3
Generalized derivation trees 4.3.1 A vocabulary for derivations: the Σ derivations signature Adjoining γ seemingly on γ John is possible in Λ(Σ trees ) because the type T does not take the node labels into account. Hence, there is, for in- [ 552 ] stance, no distinction between trees rooted by VP and trees rooted by NP. We introduce this distinction in a new signature Σ derivations = 〈A derivations , C derivations , τ derivations 〉. A derivations = V 0 is the set of nonterminal symbols of the TAG grammar G. Then, for any δ anchor ∈ I ∪ A an elementary tree of G, we define c anchor a constant of type (X 1 ⊸ • the X i are the labels of the n internal nodes of δ anchor labelled with a non-terminal where an adjunction is possible (by convention we use the breadth-first traversal); 17 • the Y i are the labels of the m leaves labelled with non-terminals, not counting the foot node if δ anchor is an auxiliary tree, of δ anchor (by convention, we use the left-right order); • let Z be the label of the root node of δ anchor . α = Z if δ anchor ∈ I is an initial tree, and α = Z ′′ ⊸ Z ′ with Z ′′ corresponding to the label of the foot node and Z ′ corresponding to the label of the root node if δ anchor ∈ A is an auxiliary tree. 18 In the latter case, we call Z ′′ ⊸ Z ′ the modifier type of the constant modelling the auxiliary tree.
We get for instance the constants typed as in (10) For each non-terminal X of the TAG grammar where an adjunction can occur, we also define I X : X ⊸ X as in (11). These constants play a similar role as I at the Σ trees level: they are used when a TAG derivation does not involve any adjunction on sites where it would be possible to have some.
17 Instead of the types (X i ⊸ X i ), we may have types X i i 1 ⊸ X i i 2 to denote a difference between the top and the bottom feature of the node of label X i . This is in particular used to account for selecting adjoining constraints as described in Feature-based TAG (FTAG: Joshi 1988, 1991). See note 18.
18 In standard TAG, we typically have Z = Z ′ = Z ′′ . However, we shall see examples in Sections 5.3.2 and 7 where the distinction between Z, Z ′ , and Z ′′ is relevant. 19 We assume that no adjunction is allowed on the V node nor on the Adv node.
[ 553 ] Then the set of typed constants of Σ derivations is C derivations = {c anchor | δ anchor ∈ I∪A}∪{I X | X ∈ V 0 } and τ derivations is the associated typing function defined as above. The typing provided by Σ derivations now disallows the application of c seemingly I VP : VP ⊸ VP to c John : NP.
We now need to relate the terms of Λ(Σ derivations ) to the terms of Λ(Σ trees ) by a suitable interpretation.
[ 554 ] However, γ 13 ̸ ∈ ( derived trees ). Indeed, there is no c 13 such that derived trees (c 13 ) = γ 13 . A simple argument using the linearity of the interpretation shows that only c seemingly (once and only once), c John (once and only once), and I X can be used. But c John can not combine with any of the other terms (none of them use the type NP). Consequently, seemingly+John ̸ ∈ ( yield • derived trees ), as is expected from the TAG grammar.

derived trees abstract terms and generalized derivation trees
It is interesting to note that abstract terms of derived trees describe the way the encoding of trees in Σ trees can combine. We can see this combination in terms such as γ 5 = γ sleeps I (γ seemingly I) γ John , but it is in some sense an artifact of the definition we gave: γ 5 β-reduces to a tree that does not show this structure anymore. However, a term such as c 5 = c sleeps I S (c seemingly I VP ) c John does not further β-reduce. Because we considered substitution as function application on arguments of atomic types and adjunction as function application on arguments of second-order types, c 5 keeps track of the adjunction of I S on c sleeps , of the adjunction of I VP on c seemingly , of the adjunction of the latter result on c sleeps , and of the substitution of c John . And the relation derived trees (c 5 ) = γ 5 expresses the relation between the record of these operations and the resulting derived tree. We can represent c 5 as a tree (see Figure 14(a)): each node corresponds to a constant, applied to the terms represented by the children of the node. It makes explicit how similar to TAG derivation trees they are ( Figure 14(b)). There is a one to one correspondence despite the following superficial differences: • in the abstract term representation, the fake adjunctions (of I X ) are represented; • instead of specifying the role of the arguments with the Gorn address, we set a specific order for the arguments.
All the objects of a TAG grammar now have an ACG counterpart: • terms of the abstract language of derived trees correspond to the TAG derivation trees; 20 • terms of Λ(Σ trees ) that are in the object language of derived trees correspond to the TAG derived trees; • terms of Λ(Σ strings ) that are in the object language of yield • derived trees correspond to the TAG generated language.
(12) and (13) illustrate these correspondences for the abstract term c 5 = c sleeps I S (c seemingly I VP ) c John representing the derivation for the analysis of John seemingly sleeps.
derived trees (c sleeps I S (c seemingly I VP ) c John ) = γ sleeps I (γ seemingly I) γ John = S 2 (NP 1 John) (VP 2 (Adv 1 seemingly) (VP 1 (V 1 sleeps))) by (5), p. 545 (13) yield • derived trees (c sleeps I S (c seemingly I VP ) c John ) = John + (seemingly + sleeps) by (12) and (8)  Remark 7 ( derived trees terms and description of trees). Let us have a look at the (X ⊸ X ) type of the argument of an abstract constant of derived trees and at its interpretation. In c sleeps for instance, the argument with type (VP ⊸ VP) is interpreted by the a variable of γ sleeps (see Table 4 on page 554). The position of a in the term S (S 2 s (a (VP 1 (V 1 sleeps)))) makes it explicit that the result of a applied to (VP 1 (V 1 sleeps)), hence the latter term itself, is dominated by the second child of S 2 (the variable s being the first one). So, in some sense, the type (VP ⊸ VP) of a corresponds to the dominance constraint between the node where a occurs (here the second child of S 2 ) and the root node of its argument (here VP 1 (V 1 sleeps)), as in the tree descriptions of Vijay-Shanker (1992): the root node of the argument of a is always dominated by the node where a occurs. In particular, replacing a by λ o x.x corresponds to having these two nodes identified.
20 There remain some reservations that Section 6 clears up, though. See Remark 8.
[ 556 ] Remark 8 (Generalized derivations and TAG derivation trees). It should be noted that derived trees and yield • derived trees are not second-order ACGs. It means that the polynomial parsing results do not directly apply. But we know that TAG parsing is polynomial. So what is happening here?
The answer is that while derived trees constrains the string language more than yield does, it does not constrain it enough to generate only the corresponding TAG language. There is indeed no difference between the type of the encoding of an elementary tree of root S with a substitution node S and the encoding of an auxiliary tree with root and foot nodes labelled by S: it is S ⊸ S in both cases.
The solution, that we develop in Section 6, is to further control ( derived trees ) with another ACG TAG such that ( TAG ) ⊂ ( derived trees ) just as derived trees allows us to control ( yield ). The general architecture is then the one that Figure 15 describes.
But while this additional control is necessary to have a faithful encoding of TAG, it is not necessary to provide the semantic interpretation of the derivation trees (and may somewhat obfuscate it). That is why we first present the syntax-semantic interface we propose and delay the final encoding of TAG (that corresponds to the one of de Groote 2002) to Section 6. In the previous section, we defined a signature Σ derivations to represent derivation structures as terms of Λ(Σ derivations ). We now use this signature as a pivot to transfer these structures into semantic representations. From a practical point of view, as mentioned in Section 3.1, it [ 557 ] amounts to defining an ACG sem. = 〈Σ derivations , Σ logic , sem. , S〉 and composing it with derived trees thanks to the shared abstract vocabulary Σ derivations . The object vocabulary Σ logic of this ACG is the vocabulary for defining the semantic representations. In this article, we use higher-order logic (and, more often than not, simply first-order logic). Other languages, such as description languages to express underspeficied representations (Bos 1995;Egg et al. 2001), modal logic languages, etc. are possible as well. But we want to focus on how to build semantic representations rather than on the semantic modelling of some linguistic phenomenon itself.

A vocabulary for semantic representations: Σ logic
We first define the object vocabulary Σ logic = 〈A logic , C logic , τ logic 〉 as in Table 5 with A logic = {e, t} the atomic types for entities and truth values respectively. As usual, we write the λ-term ∃ (λx.P) as ∃x.P. The same, mutatis mutandis, holds for ∀. Note that, in this signature, we also use the non-linear implication, as a lot of semantic formulas (e.g., adjectives and quantifiers) use non linearity of entities. But we stay within the fragment of almost linear terms as only terms of atomic type are duplicated (see Definition 5 on page 537). 21

Generalized derivation-based interpretation
The first step in defining sem. , to interpret the abstract vocabulary Σ derivations into types and terms built on the object vocabulary Σ logic , 21 For the sake of simplicity, we use simplified extensional types e and t. A more accurate semantic would require, for instance, intensional types.
Interpretation of the constants is to define the interpretation of the atomic types (S, VP…). We simply follow the standard interpretation of these syntactic types into the semantic types as proposed by Montague (1973). This results in the interpretation described in Table 6(a). The interpretation of the constants follows, as in Table 6(b). 22 We do not repeat here the type of the constants c anchor of Σ derivations , nor the constraint that the image of this type has to be the type of sem. (c anchor ) (e.g., the type of c John is NP, hence sem. (c John ) : sem. (NP) = (e → t) ⊸ t). But the reader can check that this proviso holds. We let the reader check that for our favourite example, c 5 sem. seemingly (sleep john) as (14) shows. 5.3

From derivation dependencies to semantic dependencies
We now turn to accounting for the mismatch between the dependencies as expressed in the derivation trees and in the logical semantic representations. 22 The types now also use the intuitionistic implication →. This is required when variables that are abstracted over appear more than once in the semantic recipes. This is in particular the case for entities in quantified formulas, or in the semantics of intersective adjectives (see next section).

5.3.1
Long-distance dependencies The first mismatch we consider, in order to make explicit what exactly this mismatch refers to, relates to the classical examples (15-17).
(16) Mary, Paul claims John seems to love.
(17) Who does Peter think Paul claims John seems to love?
The TAG analysis relies on the elementary trees of Figure 16 and results in the derived tree and derivation tree of Figure 17 (p. 561) for (15). The mismatch appears in the contrast between the derivation tree where α loves scopes over β claims whereas the opposite scoping is to be expected from a semantic point of view. A similar effect occurs with (16) as the derivation tree, shown in Figure 18(b) (p. 561), makes α to love scope over both β claims and β seems , while semantically both should scope over the love predicate. Moreover, the derivation tree does not specify any scoping relation between the two auxiliary trees, whereas we expect claim to semantically scope over seem. Finally, (17) and the derivation tree of Figure 19(b) (p. 562) illustrate how an element such as a wh-word can scope over a whole sentence and all its predicates while providing a semantic argument to the semantically "lowest" predicate (love).
To semantically account for these phenomena, we first extend Σ derivations and derived trees to represent the trees of Figure 16.  We now need to define the sem. interpretation that provides the expected semantic dependencies. Table 8 (p. 563) shows the lexical semantics fulfilling the requirements. The constant c loves scopes over c claims in the term c 17 = c loves (c claims I S I VP c Paul ) I VP c John c Mary , as does α loves over α claims in the derivation tree of Figure 17(b). However, looking at sem. (c loves ) in Table 8, we observe that its first argument adv S scopes over the love predicate. This argument actually corresponds to the meaning of the auxiliary tree adjoined at the S node of α loves . When it is replaced by some actual value, [ 562 ] c who : NP derived trees γ who γ who derived trees γ seems γ seems  for instance by the interpretation of (c claims I S I VP c Paul ), the predicate in this actual value (here claim) then takes scope over love, achieving the desired effect. The same holds for the adv VP argument. However, in sem. (c to love? ), the wh argument takes scope over the whole interpretation. This argument corresponds to the meaning of the constituent to be substituted at the WH node of α to love? (see Figure 16), typically λ o P.WHO P : (e ⊸ t) ⊸ t, making WHO eventually take scope over all the other predicates.
Equation (19) shows that the sem. interpretation builds the expected semantics with the required scope inversions. In terms of lexical semantics, the analysis and the account we propose are very close to the one proposed in synchronous TAG (Nesson 2009, p. 142).
Remark 9. The interpretation of c loves , c to love , and c to love? are very close to each other. Building large scale grammars would require some factoring as can be done by lexical rules or meta-grammars (Candito 1996(Candito , 1999Xia 2001;Xia et al. 2005;Crabbé et al. 2013). But in this article, we give the terms corresponding to the actual elementary trees that would be generated.

Quantification
We address in a similar way the mismatch between the scoping relation of verbal predicates over quantifiers in derivation trees and of quantifiers over verbal predicates in the logical semantic formulas. The trees of Figure 20 provide the TAG elementary trees for the TAG analysis for (20) (resp. for (21)) shown in Figure 21 (resp. in Figure 22). [ 564 ] (20) Everyone loves someone.
(21) Every man loves some woman. Remark 10. We follow the standard TAG analyses for determiners (Abeillé 1990(Abeillé , 1993XTAG Research Group 2001) where the latter adjoin on initial trees anchored by nouns, in order, in particular, to account for sequences of determiners (e.g., all these ideas) and mass nouns. While the auxiliary trees β some and β every of Figure 20 look unusual because the root node and the foot node do not have the same label, we can consider the label NP as a shorthand for the NP TAG category together with a positive (NP[+]) determiner feature. On the [ 565 ] other hand, the N label is a shorthand for the NP TAG category together with a negative (NP[−]) determiner feature. Kasper et al. (1995) and others (Rogers 1999;Kahane et al. 2000) already noted that the differences between the features on the root node and on the foot node could be reflected in allowing auxiliary trees to have different labels as root and foot nodes. While we discuss the modelling of features in TAG more generally in Section 7, the NP and N notations allow us to model the auxiliary trees of determiners with constants of the usual N ⊸ NP type (to be compared with a NP[−] ⊸ NP[+] type). While we could avoid introducing this distinction on the syntactic part of the TAG modelling, and have every node labelled with N, this distinction is semantically meaningful and records the different interpretation of N (as e → t) and NP (as (e → t) ⊸ t) (see Table 6(a) on page 559). The type of the constants modelling initial trees anchored by nouns has to be modified accordingly: it specifies that it requires an adjunction (an argument of type (N ⊸ NP)) before turning the noun into a noun phrase NP. So the type of constants (e.g., c man ) modelling initial trees anchored by nouns (e.g., α man ) is: (N ⊸ NP) ⊸ NP. It corresponds to only keeping the constants that can indeed be used in actual derivations. For each noun, we could instead introduce two constants with the following types: ( The derivation trees of Figure 21 and 22 are again such that the elementary tree of the verb predicate dominates the other elementary trees, while the respective scopes of their semantic contributions are in the reverse order. To show how this apparent mismatch can be dealt with, we extend Σ derivations with the constants of Table 9. This table also provides the interpretation of these constants by derived trees , modelling the elementary trees of Figure 20. The terms of (22) belong to ( derived trees ) and represent the derivation trees of Figure 21 [ 566 ] A syntax-semantics interface for TAG through ACG

Constants of Σ derivations
Interpretation by derived trees Then we extend sem. with the interpretations of these new constants of Σ derivations as terms of Λ(Σ logic ) ( Table 10). The semantic interpretations of the terms c 21 and c 22 are then as expected, as (24) shows.  This shows how to use the derivation tree as a pivot towards the semantic representation of an expression. The (lexical) semantic interpretation of the terms labelling the nodes of the derivation tree encodes, when necessary, the inversion of the scope of the elements. This is reminiscent of the transformation of derivation trees [ 567 ] into semantic dependency graphs of Candito and Kahane (1998) or Kallmeyer and Kuhlmann (2012). To this end, the latter implements a tree transduction-based approach (macro-tree transduction). Maskharashvili and Pogodalla (2013) discuss the relation with the present approach, relying on the encoding of macro-tree transduction within second-order ACGs (Yoshinaka 2006).
Remark 11. There are several ways to get the object scope reading. So far, the relative scopes of the subject and the object are bound to the semantic interpretation of the verb (see the semantic interpretation of c loves in Table 8 on page 563). So a possibility consists in introducing a new constant c ows loves whose semantic interpretation reverses the scope, as Equation (25) shows.
λ o adv S adv VP subj obj.adv S (obj (λ y.subj (adv VP (λx.love x y)))) Another possibility, that would go beyond what is introduced in this article, would be to use Multi-Component TAG (MCTAG: Weir 1988) as Williford (1993) proposes. In both cases, some care should be taken in order not to introduce spurious ambiguities. In Section 8.3, we provide another modelling that allows us to get this reading, and we relate it to other approaches.

Multiple adjunctions
The representation of TAG derivation trees as abstract terms of an ACG corresponds to the standard notion of derivation trees (Vijay-Shanker 1987). Schabes and Shieber (1994) call it dependent and advocate for an alternative independent notion. With dependent derivations, and in our approach, multiple adjunction on the same node is forbidden. So the analysis of (26), using the trees of Figure 23, requires first the adjunction of β big into β black , and the adjunction of the result into α dog . Figure 25(a) shows the resulting derivation tree. On the other hand, the independent adjunction shown in Figure 25(b) only specifies that both adjectives adjoin at the N node of the initial tree, corresponding to both the derived tree of Figure 24(a) and the derived tree of Figure 24 Schabes and Shieber (1994) present several arguments in favour of multiple adjunction for auxiliary trees encoding modification (as opposed to auxiliary trees encoding predication) and independent derivations. We only discuss here the semantic argument they provide. 25 The main concern again has to do with the relation between derivation trees and semantic dependencies. The dependent derivation of Figure 25(a) reflects "cascaded modifications" of the head, rather 25 The two other main arguments relate to the addition of adjoining constraints and to the addition of statistical parameters. Adding the latter to ACGs as a general framework is ongoing work, and the effects on the particular case of the TAG into ACG encoding will be considered from this perspective (Huot 2017). The argument about adjoining constraints that fail to escape intervening adjunctions is not related to the syntax-semantics interface and deserves a discussion that is beyond the scope of this article. For instance, the example of the [+] determiner feature (Section 5.3.2) that can percolate from the determiner (outmost adjunction) to the noun, despite the intervening adjunctions of the adjectives, shows that selectional restrictions can be implemented with long-distance effects.
[ 569 ] than more expected "separate modifications", the latter being only available through multiple adjunction. We show that we can actually achieve this effect in our framework, without multiple adjunction, by specifying a semantic interpretation for adjectives that encodes such a behavior.
We consider the extension of Σ derivations with the constants of Table 11 and their interpretations by derived trees and sem. of Table 12. The types of the the constants modelling adjectives follow the types proposed for constants modelling nouns. The modification they introduce builds a NP from a N, and can itself take a (N ⊸ NP) modification (adjunction) into account. Consequently, they are of type (N ⊸ NP) ⊸ N ⊸ NP. As we did for the types of the constants modelling nouns, we could enumerate the possible types taking the determiner feature into account. Because the adjunction of an adjective does not change the determiner feature, its value at the root node of the auxiliary tree only depends on what is possibly adjoined to it. So we could have four constants with the following types: ( The interpretation by sem. indeed provides a separate modification of the same variable x as argument both of big and black (a similar account would also be available in synchronous TAG).
Remark 12. By not introducing a constant I N : N ⊸ NP in Σ derivations , we require actual adjunctions of determiners (of type (N ⊸ NP), e.g., c some ) on nouns or on nouns modified by adjectives. 6 completing the tag into acg encoding So far, the abstract signatures we used, in particular Σ derivations , introduce constants that are of order strictly greater than 2. This comes in particular from the modelling of auxiliary trees as functions (typically of type X ⊸ X ), hence from having constants of higher-order type modelling the ability of a tree to take an auxiliary tree as an argument. From a theoretical point of view, we know this encoding cannot faithfully model TAG: TAG languages are polynomially parsable, and 3rd-order ACGs can generate languages in NP. Remark 8 (p. 557) gives an example of an unexpected result of this encoding: there is no way to distinguish the S ⊸ S type of an abstract constant modelling an auxiliary tree of foot node S from an abstract constant modelling an elementary tree of root S with a substitution node S.

A vocabulary for TAG derivations: the Σ TAG signature
In order to allow for the distinction between these types, we introduce atomic types (e.g., S A ) that will be interpreted as the modifier types of the constants modelling auxiliary trees. So in addition to the ACG derived trees = 〈Σ derivations , Σ trees , derived trees , S〉, we also define a higher-order signature Σ TAG = 〈A TAG , C TAG , τ TAG 〉 such that For any δ anchor ∈ I ∪ A an elementary tree of G, C anchor is a constant in C TAG with type X 1 A ⊸ · · · ⊸ X n A ⊸ Y 1 ⊸ · · · ⊸ Y m ⊸ α where: • the X i are the labels of the n internal nodes of δ anchor labelled with a non-terminal where an adjunction is possible (by convention we use the breadth-first traversal); [ 571 ] • the Y i are the labels of the m leaves of δ anchor labelled with nonterminals, not counting the foot node if δ anchor is an auxiliary tree, of δ anchor (by convention, we use the left-right order traversal); • let Z be the label of the root node of δ anchor . α = Z if δ anchor ∈ I is an initial tree, and α = Z A with Z the label of the root node if δ anchor ∈ A is an auxiliary tree.
From the elementary trees of Figure 2 (p. 533), for instance, we get the constants typed as (29) shows.
Moreover, for each non-terminal X of the TAG grammar where an adjunction can occur, we also define I X : X A . These constants play a similar role as the I X constants in Σ derivations : they are used when a TAG derivation does not involve adjunctions on sites where it would be possible to have them.
Then the set of typed constants of Σ TAG is C TAG = {C anchor | δ anchor ∈ I ∪ A} ∪ {I X | X ∈ V 0 } and τ TAG is the associated typing function defined as above. The typing provided by Σ TAG now distinguishes the type of the encoding of an elementary tree of root S with a substitution node S (type S ⊸ S) and the encoding of an auxiliary tree with root and foot nodes labelled by S (type S A , see Remark 8, p. 557). We now need to relate the terms of Λ(Σ TAG ) to the terms of Λ(Σ derivations ) by a suitable interpretation.

6.2
Interpreting Σ TAG into Λ(Σ derivations ): the TAG ACG We now can relate Σ TAG and Λ(Σ derivations ) through a new ACG TAG = 〈Σ TAG , Σ derivations , TAG , S〉 where TAG is such that: • for all α ∈ A TAG , if α = X A then TAG (α) = TAG (X A ) = X ′′ ⊸ X ′ with, most of the time, X = X ′ = X ′′ (see footnote 18 (p. 553) and Remark 13, next page), otherwise α = X ∈ A derivations and TAG (α) = TAG (X ) = X ; • for all C anchor ∈ C TAG , TAG (C anchor ) = c anchor . [ 572 ] By construction of the constants c anchor ∈ C derivations (Section. 4.3), and by construction of the constants C anchor ∈ C TAG , TAG is well defined. Table 13 sums up the constants corresponding to the elementary trees introduced so far as well as their interpretations. Because constants are interpreted as constants, the terms of Λ(Σ TAG ) and their interpretations are isomorphic. However, some terms of Λ(Σ derivations ) have no antecedent in TAG . For instance, the term Types and constants of Σ TAG Their interpretations in Λ(Σ derivations ) c sleeps (c matters I VP ) I VP c John : S ∈ ( derived trees ), where c matters : (VP ⊸ VP) ⊸ S ⊸ S corresponds to the initial tree α matters of Figure 26, as in To arrive on time matters considerably (see XTAG Research Group 2001, Section 6.31), has no antecedent. This is because the type of c matters I VP : S ⊸ S in derived trees , while it encodes an initial tree, is the same as the type of a term encoding an adjunction on a S node (see Remark 8 p. 557). But this is not true anymore at the level of TAG where C matters I VP : S ⊸ S but the type of a term encoding an adjunction on a S node is now S A . So Σ TAG allows us to add control on the admissible derivation structures that Σ derivations can provide. The general architecture is now the one of Figure 15 (p. 557). Moreover, this architecture allows us to provide, by function composition, a semantic interpretation to the constants of Σ TAG . Interestingly, this semantic interpretation derives from the more general constructions that Σ derivations enables.
Σ TAG strictly follows the abstract signature definition proposed by de Groote (2002) to encode the syntactic part of TAGs. The correctness of our encoding follows from the fact that the ACG derived trees • TAG we get by function composition is the ACG defined by de Groote (2002).
Remark 13. Because the modelling of adjunction is now controlled by the interpretation of the types X A from Σ TAG , we see that we can have more freedom in the type that is given in Σ derivations . For instance, we can set N A TAG N ⊸ NP. We can use even more complex interpretations if it helps explaining the semantic interpretation. For instance, in Section 7.2 we introduce a type S ′ A TAG (NP ⊸ S) ⊸ S to model control verbs.
We can now consider the ACG yield • derived trees • TAG , that interprets terms of Λ(Σ TAG ) into strings, and the ACG sem. • TAG , that interprets terms of Λ(Σ TAG ) into logical formulas (see Figure 15, [ 574 ] p. 557). Because Σ TAG is second-order, these two ACGs are secondorder (while yield • derived trees and sem. are not, since Σ derivations is not second-order). Hence the parsing result applies and we may parse terms with ACGs that have Σ TAG as abstract vocabulary, in particular with the ACG toolkit. The ACG example files we provide can, for instance, parse the string every + big + black + dog + usually + barks. It can also parse the logical formula ∀x. (((dog x) ∧ (black x)) ∧ (big x)) ⇒ (usually (bark x)). Note that, as a λ-term, a logical formula can generally not be replaced by a logically equivalent formula. This is an instance of the problem of logical-form equivalence (Shieber 1993) that will need to be addressed, for instance using sets of λ-terms as input (Kanazawa 2017, Section 4.2). More examples are available in the example files.

adjoining constraints and features
It is part of the TAG formalism to specify if an internal node may, may not, or must receive any adjunction. The latter case is called an obligatory adjoining (OA) constraint. In case an internal node can be subject to an adjunction operation, it is also possible to specify a restricted set of auxiliary trees, with relevant root and foot nodes, that can adjoin. This constraint is called a selective adjoining (SA) constraint. There are different ways to specify such constraints in TAG. One is to add features to the formalism. ACGs do not provide a concise way to express the abstract representation of type constraints that features offer. There have been some proposals with dependent types Pompigne 2013), but the underlying calculus does not have the expected good properties. So selection restriction has to be expressed by introducing as many types as necessary (see Section 5.3.2 for determiners and Section 5.3.3 for adjectives). To avoid the drawback of a growing size of the grammar, the addition of features, in particular morpho-syntactic ones, to ACGs remains desirable.
Note, however, that we do not want to consider features that are used to model the syntax-semantics interface Romero 2004, 2008), since we use the interpretation of derivation trees instead. We discuss the relation between the two approaches in Section 7.3.

7.1
Obligatory adjoining constraints Section 5.3.3 presents an instance of an adjoining constraint, namely an obligatory adjoining constraint. In order to form a NP, a determiner of type (N ⊸ NP) needs to be adjoined (directly or through adjectival modifications) into a noun. The obligatory nature of the adjunction is reflected by the fact that the abstract vocabulary does not provide any constant I N : N ⊸ NP simulating a fake adjunction.

Selective adjoining constraints
In Section 5.3.2, we saw an instance of using features in a TAG analysis: noun phrases can receive a determiner feature [+] or [−] indicating whether they are determined. The ACG way to account for this distinction instead consists in introducing different (atomic) types. This corresponds to specifying local adjunction constraints by enumeration as in TAG and contrary to Feature-based TAG (FTAG: Joshi 1988, 1991).
As noticed in Remark 13 (p. 574), the key here is to model auxiliary trees using an atomic type X A , so that the ACG is second-order, and to interpret this type as a functional type X ′′ ⊸ X ′ of Σ derivations , without the actual requirement that X ′′ and X ′ are atomic or that X ′′ = X ′ = X . We illustrate such an encoding with the TAG analysis of control verbs.
TAG analyzes a sentence such as (30) with an adjunction of the subject control verb wants on the reduced clause to sleep as Figure 28 shows. Figure 27 presents the elementary trees of the control verb and of the infinitive clause. This is similar to representing infinitive clauses as clauses without subjects (Abeillé 2002). For the sake of simplicity, we directly represent such a clause as an elementary tree with a PRO node.
Control and adjunction are enforced using a control feature on the S root node of the complement tree (control in XTAG (XTAG Research Group 2001, p. 98), or some semantic index idx (Gardent and Parmentier 2005;Gardent 2008)) that is to be provided by the foot node of the auxiliary tree (the control verb) which is adjoined. Moreover, in the auxiliary tree, the control feature on the foot node is co-indexed with a control feature on the subject NP (for subject control, as in (30)) or on the object NP (for object control). Figure 28 shows [ 576 ] β John = NP  (30) John wants to sleep In our ACG encoding, we model S nodes with a control feature with the functional type NP ⊸ S, expressing that such a clause is missing its subject. Consequently, the type of the constant c wants that models the auxiliary tree β wants is (S ⊸ S) ⊸ (VP ⊸ VP) ⊸ NP ⊸ (NP ⊸ S) ⊸ S. The end part (NP ⊸ S) ⊸ S of this type corresponds to the functional interpretation of the adjunction of control verbs, modelled at the Σ TAG level with the atomic type S ′ A . The difference between the type (NP ⊸ S) of the argument and the type S of the result corresponds to the different feature set attached to the root node and to the foot node of the auxiliary tree.
Then we model the feature sharing between the subject NP and the S foot node of the control verb in the semantic interpretation of the latter, as the second line of Table 16 shows: the first argument x of want x (pred (λ o P.P x)) also appears (type raised as (λ o P.P x)) as [ 577 ] 1 ε))))) c to sleep derived trees λ o cont.cont(λ o subj.S 2 (NP 1 subj) (VP 2 (V 1 to) (VP 1 sleep)))  P.P x))))) c to sleep sem. λ o cont.cont(λ o subj.subj (λx.sleep x)) the argument of pred, the latter corresponding to the semantics of the infinitive clause without subject.
Let C 28 of Λ(Σ TAG ) in (31) represent the derivation tree of Figure 28, and let c 28 be its interpretation in Λ(Σ derivations ). We can further interpret c 28 in Λ(Σ trees ) (resp. in Λ(Σ logic )) in order to have a term representing the associated derived tree (resp. semantics).

Feature sharing and semantic computation
As the previous section shows, features in TAG are taken into account in the ACG encoding using the typing discipline on the one hand, and using the (semantic) interpretation on the other hand, in particular when some value has to be shared in order to express the modifications performed by adjunction operations. Unification based approaches to semantic construction in TAG typically rely on feature sharing (Gardent and Kallmeyer 2003;Gardent and Parmentier 2005;Kallmeyer and Romero 2008) in order to [ 578 ] compositionally build the semantic representation of a sentence. In our approach, the semantic representation results from the interpretation of the derivation tree.
However, Vijay-Shanker and Joshi (1988, p. 718) already noticed that "[t]his treatment [of variable instantiation on adjunction] can be obtained if we think of the auxiliary tree as corresponding to functions over feature structures (by λ-abstracting the variable corresponding to the feature structure for the tree that will appear below the foot node). Adjunction corresponds to applying this function to the feature structure corresponding to the subtree below the node where [it] takes place". This is precisely the view we adopt here. While the typing exerts control over the admissible derivation structures, the associated computations are managed using interpretations, to compute the derived trees as well as the logical formulas. 8

derivation trees and semantic interpretations
Looking at Figure 15 (p. 557), we can consider each of the sets of λterms as independent combinatorial systems of the grammar architecture that Jackendoff (2002) describes: "Language comprises a number of independent combinatorial systems which are aligned with each other by means of a collection of interface systems. Syntax is among the combinatorial systems, but far from the only one".
Among those systems, Λ(Σ derivations ) and Λ(Σ TAG ) play a central role as their structures are the ones that are interpreted as derived trees (and as strings, by functional composition) and as logical formulas. This is not the role of the syntactic trees of Λ(Σ trees ). This emphasises that the relevant syntactic algebra to provide compositional analyses for TAG, as was noticed very early, is not the one of derived trees, but the one of derivation trees. This section further explores the modelling power it provides.
In particular, the composition of the inverse of a function and a function defines the relation (the "interface") between Λ(Σ trees ) and Λ(Σ logic ) as sem. • −1 derived trees . In general, such a composition is not a function, allowing for relating a derived tree (even more a string) with several logical formulas, and vice versa. This follows the observation of Culicover and Jackendoff (2005) that "[t]he combinatorial principles of syntax and semantics are independent; there is no 'rule-to-rule' [ 579 ] homomorphism. (…) [T]he mapping between syntactic and semantic combinatoriality is many-to-many". However, we implement the many-to-many relation with homomorphisms and inverses of homomorphisms.
In this section, we illustrate the power of this architecture that makes derivation structures a full grammatical object with three phenomena: idioms, subordinating conjunctions with reduced clauses, and scope ambiguity. For idioms, we use the fact that derivation structures are first-class citizens of the formalism. While this could also be expressed in TAG (for instance following the interpretation of derivation trees provided by Shieber 1994), this naturally fits our architecture. For subordinating conjunctions, we rely on the fact that the typing of abstract terms does not need to stick to the tree structure, and in particular to the Gorn addresses, unlike derivation trees in TAG, extending the modelling capabilities. Finally, for scope ambiguity, we show how our approach can take into account analyses from other formalisms, such as categorial and type-logical grammars. We do this remaining in the ACG model, contrary to the TAG extension (TAG with cosubstitution, Barker 2010) to which it corresponds. Other examples that go beyond TAG capabilities are discussed in Section 9, in particular for discourse parsing.

Idioms
Because TAGs provide whole fragments of phrase structures, they can encode the rigid parts of idioms as well as the ones that are subject to possible modifications. Moreover, the role of the derivation structure as a bridge to semantic interpretation nicely captures the relation between a composed syntax and an atomic meaning. With the ACG encoding of TAG, Kobele (2012) shows that we can introduce a constant term that is interpreted as the combination (by adjunction or substitution) of several elementary trees. It goes beyond the previous approaches (Abeillé and Schabes 1989;Shieber and Schabes 1990;Abeillé 1995) in that the derived tree does not need to be an elementary tree of the grammar, but is instead the result of a partial derivation.
[ 580 ] Figure 29 presents the initial trees that allow us to analyze (32) as the literal expression, with a compositional meaning built out of the composition of the initial trees α John , α kicked , β the , and α bucket . We actually syntactically analyze the idiomatic expression the same way, except that the combination of α kicked , β the , and α bucket is also considered as the interpretation of the constant c kicked the bucket . We use c kicked the bucket in the idiomatic derivation in Figure 30(c) to stress that there is no corresponding elementary tree. The ACG abstract term we get really corresponds to this derivation, as the term C 30(c) of Equation (33) shows. In both cases, the derived tree is the same (Figure 30(a)). However, the derivation trees differ, as Figure 30 Table 18 (p. 582) shows how the interpretation of the constant abstract term for the idiom is interpreted, syntactically (by derived trees ) but not semantically (by sem. ), as the interpretation of the partial derivation λ o s a subj.c kicked s a subj (c bucket c the ). Then, according to the lexicons of Tables 17, 18, and 19, (33), (34), (35), and (36) hold. They show that the two terms C 30(b) and C 30(c) have the same interpretations as derived tree by derived trees . But they have two different interpretations as logical formulas by the ACG sem. .

Subordinating conjunctions
We saw in Section 7.2 that infinitive clauses behave like clauses missing a subject. In this case, the matrix clause (control verb) adjoins on the infinitive clause. As the latter is an argument of the modifier, we could use an extra S ′ A type that was interpreted as (NP ⊸ S) ⊸ S and make the modifier fill the semantic subject with its own subject.
In the case of subordinating conjunctions, as in (37), it is the subordinate clause that adjoins on the matrix clause and uses it as argument, as Figure 31 shows: the substitution node S is meant for the reduced infinitive clause, and the foot node for adjoining into the matrix clause. But if the latter is interpreted as a full proposition, there is no way to decompose it so that its subject also fills the semantic subject position of the subordinate clause. The solution we propose uses the flexible link between the derivation and the derived trees. The constraints ACGs set on this link have to do with the type, not with the term (provided the typing is preserved). In particular: • there is no need for an adjunction on a S n node of a term in Λ(Σ trees ) to be the image of a term (in Λ(Σ derivations )) of type S. We already used this feature; • there is no need for an actual node in the derived tree to allow for an adjunction.
In order to implement the solution, terms for verbs such as c left in Table 20 have an additional argument of type ((NP ⊸ S) ⊸ (NP ⊸ S)) corresponding to the type of the auxiliary trees of subordinate clauses. The latter results for instance from the substitution of an infinitive clause of type (NP ⊸ S) into the term standing for the initial tree of a subordinating conjunction such as c in order . We can consider this additional argument as an additional possibility to get an adjunction on the S root node (the same node where a S ⊸ S adjunction is possible). As usual, in case no actual adjunction of a subordinate clause occurs, we use the I NP⊸S constant which is interpreted (syntactically and semantically) as the identity function. We can observe in derived trees (c left ) = γ left how the subordinate clause is inserted. The latter corresponds to the sub argument in γ left in Table 22 (p. 586). It takes as an argument the whole S rooted subtree over which the NP subject is abstracted (with λ o s ′ ) and the actual subject subj of the matrix clause. So it is the subordinate clause that is responsible for first applying the matrix clause to its subject before plugging in the resulting tree at the foot node. We can observe this behavior in γ in order : the sub argument corresponds to the infinitive subordinate clause to be substituted in β in order , while the matrix argument corresponds to the matrix clause into which it adjoins and to which the subj argument is given, as the subterm (matrix subj) shows.
As before, the higher-order types at the level of Σ derivations are interpretations of atomic types of Σ TAG . In particular, we introduce the atomic type S ′′ A TAG (NP ⊸ S) ⊸ (NP ⊸ S) (resp. S ws TAG NP ⊸ S) for the reduced subordinate clauses (resp. for the infinitive clause that occurs in subordinate clauses) as Table 21 shows.   With the lexicon of Tables 20, 21, and 22, we can build terms that correspond to the derivation and derived trees of Figure 32 as (38), (39), and (40) show. 26 We compute the semantic interpretation as in (41). 26 Note that all terms corresponding to initial trees where the adjunction of a subordinate clause can occur should have the extra argument added. For the sake of simplicity, only C left and c left are modified here.

Scope ambiguity and non-functional form-meaning relation
The phenomena we have modelled so far make use of derivation structures (either in Λ(Σ derivations ) or in Λ(Σ TAG )) that are very close (homomorphic) to TAG derivation trees. As we can see in Figure 15 (p. 557), the relation between TAG derivations as terms of Λ(Σ TAG ) and terms of Λ(Σ logic ) is functional (encoded by the composition sem. • TAG ). The non-functional relation is between terms of Λ(Σ trees ) and terms of Λ(Σ logic ) (encoded by the relation sem. • −1 derived trees ). So because there are two derivation trees for John kicked the bucket, there are two possible semantic interpretations. But with only one derivation tree for every man loves some woman, there is only one possible semantic interpretation. A possible solution to this problem is to use an underspecified representation formalism instead of higher-order logic to represent the semantics, as Pogodalla (2004a) proposes.
We present here another solution. It uses the power of higherorder typing of the abstract terms in order to provide TAGs with a relation between TAG derivation trees and meanings that is not functional. Nevertheless, our grammatical architecture only appeals to homomorphisms. We introduce an abstract vocabulary Σ CoTAG and two ACGs. The first one, CoTAG , maps terms of Λ(Σ CoTAG ) to terms of Λ(Σ TAG ), i.e., TAG derivation trees. The second one, co-sem. , maps terms of Λ(Σ CoTAG ) to terms of Λ(Σ logic ). It then provides a relation between Λ(Σ TAG ) and Λ(Σ logic ) as co-sem. • −1 CoTAG as Figure 33 (p. 588) shows. The derivation tree (in Λ(Σ TAG )) of every man loves some woman, for co-sem.
The idea is to use the type-raising methods of categorial and type-logical grammars. So, corresponding to a term C everyone : NP in Σ TAG , we have a term L everyone : (NP ⊸ S) ⊸ S in Σ CoTAG such that CoTAG (L everyone ) = λ o P.P C everyone . More generally, whenever a term of type A occurring within a constituent of type B can take scope over this term, we associate to C scoping : . . x n .λ o P.P (C scoping x 1 · · · x n ). For other lexical items C lex. item : α, we have L lex.item : α such that CoTAG (L lex.item ) = C lex. item . And for any atomic type A, CoTAG (A) = A. Table 23 exemplifies the approach for quantified noun phrases (note that proper [ 588 ] nouns, for instance, are not type-raised). Atomic types in Σ CoTAG are the same as in Σ TAG . With L sws 21 and L ows 21 as defined in (45) and (46) respectively, we indeed have CoTAG (L sws 21 ) = CoTAG (L ows 21 ), i.e., two different abstract terms of Λ(Σ CoTAG ) that are mapped to the same term of Λ(Σ TAG ) (TAG derivation tree).
In order to get two semantic interpretations from the two abstract terms of Λ(Σ CoTAG ), we need to directly provide them with a semantic lexicon. For if we keep on interpreting them through Σ TAG and Σ derivations , because the two terms L sws 21 and L ows 21 are interpreted as a single term in Λ(Σ TAG ), we would still get a single interpretation. In other words, we do not want the diagram of Figure 33 to commute. Table 24 defines the co-sem. interpretation into terms of Λ(Σ logic ). Contrary to sem. where NPs are interpreted with the higher-order type (e → t) ⊸ t, because quantified noun phrases are given the type (NP ⊸ S) ⊸ S in Σ CoTAG , we now interpret NP as e. All the other interpretations, in particular for verbs, are defined accordingly. 27 We can now compute the semantic interpretation of L sws 21 and L ows 21 by co-sem. . Equations (47) and (48) show that these two terms are 27 Note, however, that, because at the abstract level we only have linear types, in order to allow for non linearity at the object level, we have to uniformly interpret ⊸ as →, so that the image of (NP ⊸ S) ⊸ S is (e → t) ⊸ t. Another possibility would be to use the exponential connectives of linear logic.

Sylvain Pogodalla
L man co-sem. λdet.det man L woman co-sem. λdet.det woman mapped onto two logical formulas corresponding to the subject wide scope reading on the one hand, and to the object wide scope reading on the other hand.
This approach to scope ambiguity, first proposed by Pogodalla (2007b,a), is used by Kobele and Michaelis (2012) to provide an ACG formalization of the cosubstitution operation for TAG (Barker 2010). This also makes explicit Barker's (2010) claim that "cosubstitution is a version of the continuation-based approaches to scope-taking […]". And, indeed, the type (NP ⊸ S) ⊸ S corresponds to making the continuation of a noun phrase (i.e., its scope) part of its interpretation.
CoTAG is not a second-order ACG. In this particular case, because of lexicalization, we know that parsing is decidable, but it can be complex. Salvati (2007) presents a lexicalized third-order ACG whose membership problem reduces to an NP-complete problem. There is currently no implementation of parsing for such grammars in the ACG toolkit. The identification of fragments that are both linguistically relevant and computationally tractable is ongoing work.
This extension with more abstract levels can also be used to model (non-local) MCTAG. And one level more can control MCTAG (similar to the control that TAG adds on ( derived trees )) so that it stays within the polynomially parsable languages of set-local MCTAG (Pogodalla 2009). [ 590 ] related approaches Moving to ACGs to encode TAGs and to build TAG semantic representations offers several advantages. First, we saw in Section 3.2 that we can benefit from parsing algorithms and optimization techniques grounded in well-established fields such as type theory and Datalog.
A second advantage, also concerning the parsing algorithms, is to offer an inherently reversible framework (Dymetman 1994). Kanazawa's Datalog reduction (2007; indeed makes no hypothesis on the object language: it can be a language of strings, of trees, or of any kind of (almost linear) λ-terms. In the latter case, it can represent the usual logical semantic formulas. While in NLP parsing usually refers to building a parse structure (or a semantic term) from a string representation and generation (or surface realization) refers to building a string from a semantic representation, they both rely on ACG parsing (i.e., recovering the abstract structure from an object term), and the algorithms are the same.
This constitutes an important difference between the ACG approach and the synchronous approaches to semantic construction. If both are based on (or can be reformulated using) a tree transduction, the latter does not offer a built-in transformation to β-reduced terms (which may definitely not be trees but rather graphs) at the semantic level. When parsing strings, synchronous grammars (Nesson and Shieber 2006;Nesson 2009) build semantic trees that correspond to λ-terms before the β-reduction. Processing such trees to produce the β-reduced form is straightforward. However the inverse process, the one that is of interest for generation, is not. It actually corresponds to the morphism inversion found in ACG parsing. The ACG framework tells us that this inversion is possible, and, for the second-order case, it has actually been implemented. Kuhlmann (2011, 2012) also propose parsing by morphism inversion using interpreted regular tree grammars, and their approach completely fits the synchronous approach. But, as for synchronous TAG, this formalism is not well-suited to dealing with semantics represented with logical formulas. To parse a term t requires that the set of trees that are interpreted as t is regular. For instance, if the string algebra comes with the 2-ary concatenation operation, this [ 591 ] set is the set of all the bracketings of the string to parse (Koller and Kuhlmann 2011) (the string algebra Koller and Kuhlmann 2012 propose for the TAG encoding is different, in order to keep the complexity bound for parsing low). Applying the same approach to logical representations based on λ-calculus would mean representing all terms that are β-equivalent to the term we want to parse by a regular tree grammar. It is not clear how this can be done.
Semantic representation with λ-terms, and the ACG typetheoretic settings more generally, 28 also provides tight links with formal logical semantics. The various grammatical formalisms ACGs can encode may be linked to various semantic theories. This concerns both semantic theories, such as event semantics (Davidson 2001) (for a type-theoretic account, see Blom et al. 2012) or dynamic semantics (Kamp and Reyle 1993;Groenendijk and Stokhof 1991) (for a type-theoretic semantics account, see de Groote 2006; Martin and Pollard 2014), 29 and phenomena at the syntax-semantics interface where approaches based on underspecification (Pogodalla 2004a,b) or based on type theory and higher-order logic (Pogodalla 2007b,a;Kobele and Michaelis 2012) can be expressed.
Because they only use unification, the unification-based approaches to TAG semantics (Gardent and Kallmeyer 2003;Romero 2004, 2008) do not easily extend to higher-order semantics: only conjunctions of propositions are allowed, and no application. A first consequence is that the actual representation language needs to be embedded into a reified logical language (typically a labelled underspecified representation language). For instance, the semantics of an adverb adjoining to a VP node cannot be represented as a function from (e → t) to (e → t). It is represented as a proposition expressing that some property holds of a label which gets its value by unification with the label corresponding to the semantics of the VP in the verb initial tree. When dealing with higher-order representations, as for dynamic semantics of discourse (de Groote 2006;Martin and Pollard 28 This includes other categorial grammars (van Benthem 1986;Carpenter 1997;Steedman 2001;Steedman and Baldridge 2011). 29 Note however that the semantic calculi are somewhat extended with additional operators and then do not fulfill the requirements allowing for reversibility. This is a research program on its own.
[ 592 ] 2014), it becomes awkward to assign values of arguments with unification and to compute the semantic representation by β-reduction.
Moreover, ACGs uniformly deal with the interpretation of derivation trees, either as strings, derived trees, or semantic representations. Consequently, the same parsing algorithms apply. This is not the case for the unification-based approaches, and the reversibility of the grammars is not ensured.
Another benefit of the ACG approach to the syntax-semantics interface over the synchronous TAG or over the unification-based approach is that, by construction, it is compositional, and the homomorphism requirement between the syntactic and the semantic categories holds. For instance, in synchronous TAG, in a pair of syntactic and semantic trees, it is possible to link a node X (in the syntactic tree) with a node of type α (in the semantic tree), while having a pair of auxiliary trees whose syntactic tree has a foot and a root node labelled by X , but the nodes in the semantic trees are labelled by β ̸ = α, yielding semantic trees that are not well-typed. A similar thing can happen in unification-based approaches if the semantic features to be unified are not the same. This is not possible in ACG and the ACG toolkit would raise a typing error, in the same way that statically typed programming languages ensure type-safeness.
Finally, the modularity of the ACG framework allows us to look at TAG and TAG variants as fragments of a larger class of grammars. For instance, Multi-Component TAG (MCTAG: Weir 1988) can also be described using a similar architecture (Pogodalla 2009). It is also possible to add operations in addition to substitution and adjunction that would otherwise be difficult, if not impossible, to express as TAG (or MCTAG) operations. Such operations can be used in order to link a TAG phrase grammar with a TAG discourse grammar without requiring an intermediate processing step (Danlos et al. 2015(Danlos et al. , 2016, contrary to D-LTAG (Webber and Joshi 1998;Forbes et al. 2003;Webber 2004;Forbes-Riley et al. 2006) or D-STAG (Danlos , 2011. But, provided the encoding remains in the second-order ACG class, these grammars remain reversible and there is no need to design new parsing algorithms. [ 593 ] conclusion We have presented a model of the syntax-semantics interface for TAGs hinging on the ACG framework. We demonstrated, with the help of classical TAG syntax-semantics examples and new modellings, that this framework offers a lot of flexibility and expressiveness. In particular, we built on the modular properties of ACG that result from the two notions of composition between grammars it provides. These composition modes have been used for the syntax-semantics interface on the one hand, and for restricting the derivations to actual TAG derivations using a second-order ACG on the other hand. This allowed us to apply the ACG parsing results and to make the grammar reversible so that both parsing and syntactic realization are available.
Moreover, we showed that new modellings can be proposed that extend the standard TAG analyses without the requirement of designing new parsing algorithms. This was illustrated with phenomena such as idioms and subordinating conjunctions. We also showed what we can bring into TAG accounts from type-logical frameworks, such as the modelling of scope ambiguities.
This shows how relevant ACGs are as models of the syntaxsemantics interface in general, and for TAG in particular. Relying on the work we have presented here, we can consider modelling other standard extensions of TAGs, such as MCTAG. We can also consider relating TAG to other type-theoretic modellings of semantic phenomena, e.g., discourse, knowledge and beliefs, time, etc. Finally, we believe this can give a new perspective on ways to model phenomena which are challenging to model otherwise in TAG, such as coordination.