<?xml version="1.0" standalone="yes"?>
<Paper uid="P01-1033">
  <Title>Towards Abstract Categorial Grammars</Title>
  <Section position="2" start_page="0" end_page="0" type="intro">
    <SectionTitle>
1 Introduction
</SectionTitle>
    <Paragraph position="0"> Type-logical grammars offer a clear cut between syntax and semantics. On the one hand, lexical items are assigned syntactic categories that combine via a categorial logic akin to the Lambek calculus (Lambek, 1958). On the other hand, we have so-called semantic recipes, which are expressed as typed l-terms. The syntax-semantics interface takes advantage of the Curry-Howard correspondence, which allows semantic readings to be extracted from categorial deductions (van Benthem, 1986). These readings rely upon a homomorphism between the syntactic categories and the semantic types.</Paragraph>
    <Paragraph position="1"> The distinction between syntax and semantics is of course relevant from a linguistic point of view. This does not mean, however, that it must be wired into the computational model. On the contrary, a computational model based on a small set of primitives that combine via simple composition rules will be more flexible in practice and easier to implement.</Paragraph>
    <Paragraph position="2"> In the type-logical approach, the syntactic contents of a lexical entry is outlined by the following patern: &lt;atom&gt; : &lt;syntactic category&gt; On the other hand, the semantic contents obeys the following scheme: &lt;l-term&gt; : &lt;semantic type&gt; This asymmetry may be broken by: 1. allowing l-terms on the syntactic side (atomic expressions being, after all, particular cases of l-terms), 2. using the same type theory for expressing both the syntactic categories and the semantic types.</Paragraph>
    <Paragraph position="3"> The first point is a powerfull generalization of the usual scheme. It allows l-terms to be used at a syntactic level, which is an approach that has been advocated by (Oehrle, 1994). The second point may be satisfied by dropping the non-commutative (and non-associative) aspects of categorial logics. This implies that, contrarily to the usual categorial approaches, word order constraints cannot be expressed at the logical level. As we will see this apparent loss in expressive power is compensated by the first point.</Paragraph>
    <Paragraph position="4"> 2 Definition of a multiplicative kernel In this section, we define an elementary grammatical formalism based on the ideas presented in the introduction. This elementary formalism is founded on the multiplicative fragment of linear logic (Girard, 1987). For this reason, we call it a multiplicative kernel. Possible extensions based on other fragments of linear logic are discussed in Section 5.</Paragraph>
    <Section position="1" start_page="0" end_page="0" type="sub_section">
      <SectionTitle>
2.1 Types, signature, and l-terms
</SectionTitle>
      <Paragraph position="0"> We first introduce the mathematical apparatus that is needed in order to define our notion of an abstract categorial grammar.</Paragraph>
      <Paragraph position="1"> Let A be a set of atomic types. The set T (A) of linear implicative types built upon A is inductively defined as follows:  1. if a [?] A, then a [?] T (A); 2. if a,b [?] T (A), then (a[?]*b) [?] T (A). We now introduce the notion of a higher-order linear signature. It consists of a triple S = &lt;A,C,t&gt; , where: 1. A is a finite set of atomic types; 2. C is a finite set of constants; 3. t : C - T (A) is a function that assigns to  each constant in C a linear implicative type in T (A).</Paragraph>
      <Paragraph position="2"> Let X be a infinite countable set of l-variables. The set L(S) of linear l-terms built upon a higher-order linear signature S = &lt;A,C,t&gt; is inductively defined as follows:  1. if c [?] C, then c [?] L(S); 2. if x [?] X, then x [?] L(S); 3. if x [?] X, t [?] L(S), and x occurs free in t exactly once, then (lx.t) [?] L(S); 4. if t,u [?] L(S), and the sets of free variables of t and u are disjoint, then (tu) [?] L(S). L(S) is provided with the usual notion of cap null ture avoiding substitution, a-conversion, and breduction (Barendregt, 1984).</Paragraph>
      <Paragraph position="3"> Given a higher-order linear signature S = &lt;A,C,t&gt; , each linear l-term in L(S) may be assigned a linear implicative type in T (A). This type assignment obeys an inference system whose judgements are sequents of the following form: G [?]S t : a where:  1. G is a finite set of l-variable typing declarations of the form 'x : b' (with x [?] X and b [?] T (A)), such that any l-variable is declared at most once; 2. t [?] L(S); 3. a [?] T (A).</Paragraph>
      <Paragraph position="4">  The axioms and inference rules are the following:  We now introduce the abstract notions of a vocabulary and a lexicon, on which the central notion of an abstract categorial grammar is based. A vocabulary is simply defined to be a higher-order linear signature.</Paragraph>
      <Paragraph position="5"> Given two vocabularies S1 = &lt;A1,C1,t1&gt; and S2 = &lt;A2,C2,t2&gt; , a lexicon L from S1 to S2 (in notation, L : S1 - S2) is defined to be a pair L = &lt;F,G&gt; such that:  1. F : A1 - T (A2) is a function that interprets the atomic types of S1 as linear implicative types built upon A2; 2. G : C1 - L(S2) is a function that interprets the constants of S1 as linear l-terms built upon S2; 3. the interpretation functions are compatible  with the typing relation, i.e., for any c [?] C1, the following typing judgement is derivable:</Paragraph>
      <Paragraph position="7"> where ^F is the unique homomorphic extension of F.</Paragraph>
      <Paragraph position="8"> As stated in Clause 3 of the above definition, there exists a unique type homomorphism ^F : T (A1) - T (A2) that extends F. Similarly, there exists a unique l-term homomorphism ^G : L(S1) - L(S2) that extends G. In the sequel, when 'L' will denote a lexicon, it will also denote the homorphisms ^F and ^G induced by this lexicon. In any case, the intended meaning will be clear from the context.</Paragraph>
      <Paragraph position="9"> Condition 3, in the above definition of a lexicon, is necessary and sufficient to ensure that the homomorphisms induced by a lexicon commute with the typing relations. In other terms, for any lexicon L : S1 - S2 and any derivable judgement null x0: a0,...,xn: an [?]S1 t : a the following judgement x0: L(a0),...,xn: L(an) [?]S2 L(t): L(a) is derivable. This property, which is reminiscent of Montague's homomorphism requirement (Montague, 1970b), may be seen as an abstract realization of the compositionality principle. We are now in a position of giving the definition of an abstract categorial grammar.</Paragraph>
      <Paragraph position="10"> An abstract categorial grammar (ACG) is a  quadruple G = &lt;S1,S2,L,s&gt; where: 1. S1 = &lt;A1,C1,t1&gt; and S2 = &lt;A2,C2,t2&gt; are two higher-order linear signatures; S1 is called the abstract vovabulary and S2 is called the object vovabulary; 2. L : S1 - S2 is a lexicon from the abstract vovabulary to the object vovabulary; 3. s [?] T (A1) is a type of the abstract vocabu null lary; it is called the distinguished type of the grammar.</Paragraph>
      <Paragraph position="11"> Any ACG generates two languages, an abstract language and an object language. The abstract language generated by G (A(G)) is defined as follows: A(G) = {t [?] L(S1) |[?]S1 t: s is derivable} In words, the abstract language generated by G is the set of closed linear l-terms, built upon the abstract vocabulary S1, whose type is the distinguished type s. On the other hand, the object language generated by G (O(G)) is defined to be the image of the abstract language by the term homomorphism induced by the lexicon L:</Paragraph>
      <Paragraph position="13"> It may be useful of thinking of the abstract language as a set of abstract grammatical structures, and of the object language as the set of concrete forms generated from these abstract structures.</Paragraph>
      <Paragraph position="14"> Section 4 provides examples of ACGs that illustrate this interpretation.</Paragraph>
    </Section>
    <Section position="2" start_page="0" end_page="0" type="sub_section">
      <SectionTitle>
2.3 Example
</SectionTitle>
      <Paragraph position="0"> In order to exemplify the concepts introduced so far, we demonstrate how to accomodate the PTQ fragment of Montague (1973). We concentrate on Montague's famous sentence: John seeks a unicorn (1) For the purpose of the example, we make the two following assumptions:  1. the formalism provides an atomic type 'string' together with a binary associative operator '+' (that we write as an infix op null erator for the sake of readability); 2. we have the usual logical connectives and quantifiers at our disposal.</Paragraph>
      <Paragraph position="1"> We will see in Section 4 and 5 that these two assumptions, in fact, are not needed.</Paragraph>
      <Paragraph position="2"> In order to handle the syntactic part of the example, we define an ACG (G12). The first step consists in defining the two following vocabularies: null</Paragraph>
      <Paragraph position="4"> Sdicto mapsto- (np [?]*(np [?]*s)), A mapsto- (n[?]* np), U mapsto- n} &gt;</Paragraph>
      <Paragraph position="6"> {John mapsto- string, seeks mapsto- string, a mapsto- string,unicorn mapsto- string} &gt; Then, we define a lexicon L12 from the abstract  vocabulary S1 to the object vocabulary S2: L12 = &lt; {n mapsto- string,np mapsto- string, s mapsto- string}, {J mapsto- John, Sre mapsto- lx.ly.x+seeks+y, Sdicto mapsto- lx.ly.x+seeks+y, A mapsto- lx.a+x, U mapsto- unicorn} &gt;  Finally we have G12 = &lt;S1,S2,L12,s&gt; . The semantic part of the example is handled by another ACG (G13), which shares with G12 the same abstract language. The object language of this second ACG is defined as follows:</Paragraph>
      <Paragraph position="8"> {JOHN, TRY-TO, FIND, UNICORN}, {JOHN mapsto- e, TRY-TO mapsto- (e[?]*((e[?]*t)[?]*t)), FIND mapsto- (e[?]*(e[?]*t)), UNICORN mapsto- (e[?]*t)} &gt; Then, a lexicon from S1 to S3 is defined: L13 = &lt; {n mapsto- (e[?]*t),np mapsto- ((e[?]*t)[?]*t), s mapsto- t}, {J mapsto- lP.P JOHN, Sre mapstolP.lQ.Q(lx.P null (ly. TRY-TO y(lz. FIND zx))), Sdicto mapstolP.lQ.P null (lx. TRY-TO x (ly.Q(lz. FIND yz))), A mapsto- lP.lQ.[?]x.P x[?]Qx, U mapsto- lx. UNICORN x} &gt;  This allows the ACG G13 to be defined as &lt;S1,S3,L13,s&gt; .</Paragraph>
      <Paragraph position="9"> The abstract language shared by G12 and G13 contains the two following terms: Sre J (AU) (2) Sdicto J (AU) (3) The syntactic lexiconL12 applied to each of these terms yields the same image. It b-reduces to the following object term: John+seeks+a+unicorn On the other hand, the semantic lexicon L13 yields the de re reading when applied to (2): [?]x. UNICORN x[?] TRY-TO JOHN (lz. FIND zx) and it yields the de dicto reading when applied to (3): TRY-TO JOHN (ly.[?]x. UNICORN x[?] FIND yx) Our handling of the two possible readings of (1) differs from the type-logical account of Morrill (1994) and Carpenter (1996). The main difference is that our abstract vocabulary contains two constants corresponding to seek. Consequently, we have two distinct entries in the semantic lexicon, one for each possible reading. This is only a matter of choice. We could have adopt Morrill's solution (which is closer to Montague original analysis) by having only one abstract constant S together with the following type assignment: S mapsto- (np[?]*(((np[?]*s)[?]*s)[?]*s)) Then the types of J and A, and the two lexicons should be changed accordingly. The semantic lexicon of this alternative solution would be simpler. The syntactic lexicon, however, would be more involved, with entries such as:  Compositional semantics associates meanings to utterances by assigning meanings to atomic items, and by giving rules that allows to compute the meaning of a compound unit from the meanings of its parts. In the type logical approach, following the Montagovian tradition, meanings are expressed as typed l-terms and combine via functional application.</Paragraph>
      <Paragraph position="10"> Dalrymple et al. (1995) offer an alternative to this applicative paradigm. They present a deductive approach in which linear logic is used as a glue language for assembling meanings. Their approach is more in the tradition of logic programming. null The grammatical framework introduced in the previous section realizes the compositionality principle in a abstract way. Indeed, it provides compositional means to associate the terms of a given language to the terms of some other language. Both the applicative and deductive paradigms are available.</Paragraph>
    </Section>
    <Section position="3" start_page="0" end_page="0" type="sub_section">
      <SectionTitle>
3.1 Applicative paradigm
</SectionTitle>
      <Paragraph position="0"> In our framework, the applicative paradigm consists simply in computing, according to the lexicon of a given grammar, the object image of an abstract term. From a computational point of view it amounts to performing substitution and breduction. null</Paragraph>
    </Section>
    <Section position="4" start_page="0" end_page="0" type="sub_section">
      <SectionTitle>
3.2 Deductive paradigm
</SectionTitle>
      <Paragraph position="0"> The deductive paradigm, in our setting, answers the following problem: does a given term, built upon the object vocabulary of an ACG, belong to the object language of this ACG. It amounts to a kind of proof-search that has been described by Merenciano and Morrill (1997) and by Pogodalla (2000). This proof-search relies on linear higher-order matching, which is a decidable problem (de Groote, 2000).</Paragraph>
    </Section>
    <Section position="5" start_page="0" end_page="0" type="sub_section">
      <SectionTitle>
3.3 Transductive paradigm
</SectionTitle>
      <Paragraph position="0"> The example developped in Section 2.3 suggests a third paradigm, which is obtained as the composition of the applicative paradigm with the deductive paradigm. We call it the transductive paradigm because it is reminiscent of the mathematical notion of transduction (see Section 4.2). This paradigm amounts to the transfer from one object language to another object language, using a common abstract language as a pivot.</Paragraph>
    </Section>
  </Section>
class="xml-element"></Paper>