#############################################################
# #
# arabic.ccg #
# #
#############################################################
# Author: Ben Wing <ben@666.com>
# Date: April 2006
# This is a grammar for a fragment of Arabic. It's particularly
# useful for demonstrating the extended use of macros to handle
# complicated morphological inflections.
# See the `tiny' grammar (tiny.ccg) for more info about the format
# of this file.
feature {
CASE<2>: nom, acc, gen;
NUM<2>: sg, du, pl;
GEND<2>: m, f;
STATE<2>: cons, non-cons {indef, def};
ANIM<2>: hum, nonhum;
PERS<2>: 1st, 2nd, 3rd;
RESUMPTIVE<2>: nonres, res;
SEM-NUM<X:NUM>: sg-X, du-X, pl-X;
SEM-PERS<X:PERS>: 1st-X, 2nd-X, 3rd-X;
TENSE<E>: past, pres;
MOOD<E>: indic, subj, juss;
# Here's a more complicated hierarchy, from the original tiny grammar.
ontology: sem-obj {
phys-obj {
animate-being {
person
},
thing
},
situation {
change {
action
},
state
}
};
}
rule {
no typeraise;
typeraise +: n => s;
typeraise - $: n => s;
typeraise - $: pp => s;
typeraise - $: pp/n => s;
typechange: s$1 | n[nom] => s$1 ;
typechange: n<~2>[cons] => n<2>[3rd,def] /* n[gen,def] ;
typechange: n<~2>[cons] => n<2>[3rd,indef] /* n[gen,indef] ;
}
##########################################################################
# Morphological entries #
# (morph.xml) #
##########################################################################
word wa:Conj; # "and"
word anna:Comp; # "that", introducing sentential complements
word inna:Comp; # same, but only after the verb qaal "say"
word maa:InterrogPro(thing): 3rd; # "what"
word man:InterrogPro(person): 3rd; # "who"
word li:Prep; # "what"
word fii:Prep; # "who"
# This word means "this".
word haadhaa {
*: sg, m;
haadhihi: sg, f;
ha_ulaahi: pl;
# Bizarrely, this word declines for case only in the dual.
haadhaani: du, m, nom;
haadhayni: du, m, acc;
haadhayni: du, m, gen;
haataani: du, f, nom;
haatayni: du, f, acc;
haatayni: du, f, gen;
}
# This word means "that".
word dhaalik {
*: sg, m;
tilka: sg, f;
ulaa_ika: pl;
# Bizarrely, this word declines for case only in the dual.
dhaanika: du, m, nom;
dhaynika: du, m, acc;
dhaynika: du, m, gen;
taanika: du, f, nom;
taynika: du, f, acc;
taynika: du, f, gen;
}
# This is the relative pronoun.
word al-ladhii {
*: sg, m;
al-latii: sg, f;
al-ladhiina: pl, m;
al-laati: pl, f;
# Bizarrely, this word declines for case only in the dual.
al-ladhaani: du, m, nom;
al-ladhayni: du, m, acc;
al-ladhayni: du, m, gen;
al-lataani: du, f, nom;
al-latayni: du, f, acc;
al-latayni: du, f, gen;
}
word pro:Pro {
ana: 1st, 1st-X, sg, sg-X;
anta: 2nd, 2nd-X, sg, sg-X, m;
anti: 2nd, 2nd-X, sg, sg-X, f;
huwa: 3rd, 3rd-X, sg, sg-X, m;
hiya: 3rd, 3rd-X, sg, sg-X, f;
naHnu: 1st, 1st-X, pl, pl-X;
antun: 2nd, 2nd-X, pl, pl-X, m;
antunna: 2nd, 2nd-X, pl, pl-X, f;
hum: 3rd, 3rd-X, pl, pl-X, m;
hunna: 3rd, 3rd-X, pl, pl-X, f;
}
word ii:: 1st, 1st-X, sg, sg-X;
word nii:: 1st, 1st-X, sg, sg-X;
word ka:: 2nd, 2nd-X, sg, sg-X, m;
word ki:: 2nd, 2nd-X, sg, sg-X, f;
word hu:: 3rd, 3rd-X, sg, sg-X, m;
word haa:: 3rd, 3rd-X, sg, sg-X, f;
word naa:: 1st, 1st-X, pl, pl-X;
word kum:: 2nd, 2nd-X, pl, pl-X, m;
word kunna:: 2nd, 2nd-X, pl, pl-X, f;
word hum:: 3rd, 3rd-X, pl, pl-X, m;
word hunna:: 3rd, 3rd-X, pl, pl-X, f;
#############################################
# Nouns #
#############################################
# This shows how a reasonably complicated morphology can be accommodated.
# It is certainly possible that some of this may (and probably should)
# be offloaded into a separate morphology-processing engine. However,
# even in that case there is often a good deal more to the lexicon.
# We show a couple examples of complete paradigms, in order to make it
# easier to understand what's going on below.
# Here is a typical noun (kitaab "book") with a broken plural (kutub "books").
# For nouns with broken plurals, the plural is typically declined like
# the singular. Note that Arabic nouns are conjugated for three numbers
# (singular, dual, plural), three cases (nominative, accusative, dative),
# and three states (indefinite, definite, construct). (The construct state
# is used for nouns that are modified by other nouns -- e.g. "book" in
# "the book of Mary".)
# Form Nominative Accusative Dative
# ---------------------------------------------------------------
# sg.indef kitaabun kitaaban kitaabin
# sg.def al-kitaabu al-kitaaba al-kitaabi
# sg.cons kitaabu kitaaba kitaabi
#
# du.indef kitaabaani kitaabayni kitaabayni
# du.def al-kitaabaani al-kitaabayni al-kitaabayni
# du.cons kitaabaa kitaabay kitaabay
#
# pl.indef kutubun kutuban kutubin
# pl.def al-kutubu al-kutuba al-kutubi
# pl.cons kutubu kutuba kutubi
# Here is a typical noun (mudarris "teacher") with a different kind of
# plural, a so-called "strong masculine plural", which has its own declension.
# Form Nominative Accusative Dative
# ---------------------------------------------------------------
# sg.indef mudarrisun mudarrisan mudarrisin
# sg.def al-mudarrisu al-mudarrisa al-mudarrisi
# sg.cons mudarrisu mudarrisa mudarrisi
#
# du.indef mudarrisaani mudarrisayni mudarrisayni
# du.def al-mudarrisaani al-mudarrisayni al-mudarrisayni
# du.cons mudarrisaa mudarrisay mudarrisay
#
# pl.indef mudarrisuuna mudarrisiina mudarrisiina
# pl.def al-mudarrisuuna al-mudarrisiina al-mudarrisiina
# pl.cons mudarrisuu mudarrisii mudarrisii
# Here, we make heavy use of macros.
# This macro says: Every time an expression of the form
# three-form-decl(...) occurs, replace it with the text that comes after.
# The parameters will be substituted into the text. The braces that
# denote the macro's text do *NOT* form part of the text that is substituted.
# Note that macro substitutions are processed recursively: If the text
# of a macro substitution contains calls to other macros, they will also
# be processed. This makes "inheritance" very easy to implement.
# This macro is used for a particular paradigm corresponding to a
# particular number of a word.
def three-different-form-decl(indef-form, def-form, cons-form,
indef-nom, indef-acc, indef-gen,
def-nom, def-acc, def-gen,
cons-nom, cons-acc, cons-gen,
morph-num, sem-num, gend) {
indef-form.indef-nom: morph-num, sem-num, gend, nom, indef;
indef-form.indef-acc: morph-num, sem-num, gend, acc, indef;
indef-form.indef-gen: morph-num, sem-num, gend, gen, indef;
add-al(def-form.def-nom): morph-num, sem-num, gend, nom, def;
add-al(def-form.def-acc): morph-num, sem-num, gend, acc, def;
add-al(def-form.def-gen): morph-num, sem-num, gend, gen, def;
cons-form.cons-nom: morph-num, sem-num, gend, nom, cons;
cons-form.cons-acc: morph-num, sem-num, gend, acc, cons;
cons-form.cons-gen: morph-num, sem-num, gend, gen, cons;
}
# It's questionable whether we should do this. This assimilates al-
# to a following coronal consonant, e.g. ar-rajul, as-sigaara,
# ath-thalj, an-nuur, aDH-DHuhr, etc.
def add-al(form) regsub('^al-([std]h|DH|[tdszrnTDSZL])', 'a\1-\1', al-.form)
def three-form-decl(form, indef-nom, indef-acc, indef-gen,
def-nom, def-acc, def-gen,
cons-nom, cons-acc, cons-gen,
morph-num, sem-num, gend) {
three-different-form-decl(form, form, form,
indef-nom, indef-acc, indef-gen,
def-nom, def-acc, def-gen,
cons-nom, cons-acc, cons-gen,
morph-num, sem-num, gend)
}
# Using the above macro, we create two more macros to handle two common
# paradigm types: Accusative and genitive are the same, and the
# definite is either the same as the construct (two-form-decl-1) or
# the same as the indefinite (two-form-decl-2).
def two-form-decl-1(form, non-cons-nom, non-cons-obl,
cons-nom, cons-obl, morph-num, sem-num, gend) {
three-form-decl(form, non-cons-nom, non-cons-obl, non-cons-obl,
non-cons-nom, non-cons-obl, non-cons-obl,
cons-nom, cons-obl, cons-obl,
morph-num, sem-num, gend)
}
def two-form-decl-2(form, indef-nom, indef-obl,
non-indef-nom, non-indef-obl, morph-num, sem-num, gend) {
three-form-decl(form, indef-nom, indef-obl, indef-obl,
non-indef-nom, non-indef-obl, non-indef-obl,
non-indef-nom, non-indef-obl, non-indef-obl,
morph-num, sem-num, gend)
}
# In turn we create macros for particular paradigms: strong masculine ("uun"),
# strong feminine ("aat"), dual, and basic triptote (the paradigm for
# "kitaab" above and, in general, most singulars).
# Note that an alternative to using braces is to put the macro text on
# the same line as the `def' part of the macro (backslashes can be used
# to join multiple lines together).
def uun-plural(form) two-form-decl-1(form, uuna, iina, uu, ii, pl, pl-X, m)
def aat-plural(form) \
two-form-decl-2(form, aatun, aatin, aatu, aati, pl, pl-X, f)
def dual(form, gend) \
two-form-decl-1(form, aani, ayni, aa, ay, du, du-X, gend)
def triptote(form, morph-num, sem-num, gend) \
three-form-decl(form, un, an, in, u, a, i, u, a, i, morph-num, sem-num, gend)
# Here we define macros for full paradigms for words. Note how semicolons
# are not used, because they are supplied by the macro text itself.
# (Consult the text for three-form-decl() above, and remember that the
# braces denoting the macro text are not actually part of the text. This
# means that if you really want braces as the outermost thing in some
# macro text, you'll need to supply two levels of braces.)
def thing(sing, plur) {
word sing:N(thing) {
triptote(sing, sg, sg-X, m)
dual(sing, m)
triptote(plur, sg, pl-X, f)
}
}
def fem-thing(sing, plur) {
word sing:N(thing) {
triptote(sing.t, sg, sg-X, f)
dual(sing.t, f)
triptote(plur, sg, pl-X, f)
}
}
def person(sing, plur, gend) {
word sing:N(person) {
triptote(sing, sg, sg-X, gend)
dual(sing, gend)
triptote(plur, pl, pl-X, gend)
}
}
def male(sing, plur) person(sing, plur, m)
def female(sing, plur) person(sing, plur, f)
def strong-male(sing) {
word sing:N(person) {
triptote(sing, sg, sg-X, m)
dual(sing, m)
uun-plural(sing)
}
}
# Here we define the actual words. Note how short these definitions are,
# specifying only what's unpredictable.
thing(kitaab, kutub)
thing(waqt, _awqaat)
thing(Harf, Huruuf)
thing(dars, duruus)
thing(waqt, _awqaat)
fem-thing(sigaara, sagaayir)
fem-thing(madiina, mudun)
male(rajul, rijaal)
male(walad, _awlaad)
male(Taalib, Tullaab)
female(bint, _abnaat)
strong-male(mudarris)
word imra_a:N(person) {
three-different-form-decl(imra_at, mar_at, imra_at,
un, an, in, u, a, i, u, a, i,
sg, sg-X, f)
three-different-form-decl(imra_at, mar_at, imra_at,
aani, ayni, ayni, aani, ayni, ayni, aa, ay, ay,
du, du-X, f)
triptote(nisaa_, pl, pl-X, f)
}
def extended_construct_word(stem, plur) {
word stem:N(person) {
three-form-decl(stem, un, an, in, u, a, i, uu, aa, ii, sg, sg-X, m)
dual(stem, m)
triptote(plur, pl, pl-X, m)
}
}
extended_construct_word(_ax, _ixwaan)
extended_construct_word(_ab, _abnaa_)
# Typical paradigms:
# 1sg 'aktaa 'aktaa 'akta |
# 2sg.m taktaa taktaa takta |
# 2sg.f taktayna taktay taktay |
# 3sg.m yaktaa yaktaa yakta |
# 3sg.f taktaa taktaa takta |
# 2du taktayaani taktayaa taktayaa |
# 3du.m yaktayaani yaktayaa yaktayaa |
# 3du.f taktayaani taktayaa taktayaa |
# 1pl naktaa naktaa nakta |
# 2pl.m taktawna taktaw taktaw |
# 2pl.f taktayna taktayna taktayna |
# 3pl.m yaktawna yaktaw yaktaw |
# 3pl.f yaktayna yaktayna yaktayna |
#
# 1sg 'aktuu 'aktuwa 'aktu | 'aktii 'aktiya 'akti
# 2sg.m taktuu taktuwa taktu | taktii taktiya takti
# 2sg.f taktiina taktii taktii | taktiina taktii taktii
# 3sg.m yaktuu yaktuwa yaktu | yaktii yaktiya yakti
# 3sg.f taktuu taktuwa taktu | taktii taktiya takti
# 2du taktuwaani taktuwaa taktuwaa | taktiyaani taktiyaa taktiyaa
# 3du.m yaktuwaani yaktuwaa yaktuwaa | yaktiyaani yaktiyaa yaktiyaa
# 3du.f taktuwaani taktuwaa taktuwaa | taktiyaani taktiyaa taktiyaa
# 1pl naktuu naktuwa naktu | naktii naktiya nakti
# 2pl.m taktuuna taktuu taktuu | taktuuna taktuu taktuu
# 2pl.f taktuuna taktuuna taktuuna | taktiina taktiina taktiina
# 3pl.m yaktuuna yaktuu yaktuu | yaktuuna yaktuu yaktuu
# 3pl.f yaktuuna yaktuuna yaktuuna | yaktiina yaktiina yaktiina
def two-form-past(formv, formc) {
formc.tu: past, 1st, sg;
formc.ta: past, 2nd, m, sg;
formc.ti: past, 2nd, f, sg;
formv.a: past, 3rd, m, sg;
formv.at: past, 3rd, f, sg;
formc.tumaa: past, 2nd, du;
formv.aa: past, 3rd, m, du;
formv.ataa: past, 3rd, f, du;
formc.naa: past, 1st, pl;
formc.tum: past, 2nd, m, pl;
formc.tunna: past, 2nd, f, pl;
formv.uu: past, 3rd, m, pl;
formc.na: past, 3rd, f, pl;
}
def 3rd-weak-past-ay(form) {
form.ay.tu: past, 1st, sg;
form.ay.ta: past, 2nd, m, sg;
form.ay.ti: past, 2nd, f, sg;
form.aa: past, 3rd, m, sg;
form.at: past, 3rd, f, sg;
form.ay.tumaa: past, 2nd, du;
form.ay.aa: past, 3rd, m, du;
form.ataa: past, 3rd, f, du;
form.ay.naa: past, 1st, pl;
form.ay.tum: past, 2nd, m, pl;
form.ay.tunna: past, 2nd, f, pl;
form.aw: past, 3rd, m, pl;
form.ay.na: past, 3rd, f, pl;
}
def 3rd-weak-past-aw(form) {
form.aw.tu: past, 1st, sg;
form.aw.ta: past, 2nd, m, sg;
form.aw.ti: past, 2nd, f, sg;
form.aa: past, 3rd, m, sg;
form.at: past, 3rd, f, sg;
form.aw.tumaa: past, 2nd, du;
form.aw.aa: past, 3rd, m, du;
form.ataa: past, 3rd, f, du;
form.aw.naa: past, 1st, pl;
form.aw.tum: past, 2nd, m, pl;
form.aw.tunna: past, 2nd, f, pl;
form.aw: past, 3rd, m, pl;
form.aw.na: past, 3rd, f, pl;
}
def 3rd-weak-past-ii(form) {
form.ii.tu: past, 1st, sg;
form.ii.ta: past, 2nd, m, sg;
form.ii.ti: past, 2nd, f, sg;
form.iya: past, 3rd, m, sg;
form.iyat: past, 3rd, f, sg;
form.ii.tumaa: past, 2nd, du;
form.iy.aa: past, 3rd, m, du;
form.iy.ataa: past, 3rd, f, du;
form.ii.naa: past, 1st, pl;
form.ii.tum: past, 2nd, m, pl;
form.ii.tunna: past, 2nd, f, pl;
form.uu: past, 3rd, m, pl;
form.ii.na: past, 3rd, f, pl;
}
def strong-past(form) two-form-past(form, form)
# In general, almost all Arabic present-tense verbs of a particular mood
# can be defined using five forms. Verbs with a hamza in the first radical
# have a problem in the first-singular; ideally this should be handled
# automatically using a regexp or something of that sort, but we don't have
# such support currently, so we use an optional param.
def gen-pres(mood, fsing, fsing-fem, fdual, fplur-masc, fplur-fem) {
# This shows how you can use regular expressions if need be.
# regsub(string, regex, repl) is a special built-in that does regular-
# expression substitution on STRING, replacing all occurrences of
# REGEX with REPL. Regular-expression syntax is as in Python.
# In this case, Arabic verbs have a phonetic rule that eliminates
# two glottal stops occurring near each other at the beginning of a
# word. For example, _a_kulu -> _aakulu, and _u_kalu -> _uukalu.
# (That is, the vowel is lengthened.)
# _ . regsub(foo, bar, fsing): pres, mood, 1st, sg;
_ . regsub('^([aiu])_', '\1\1', fsing): pres, mood, 1st, sg;
# _.fsing: pres, mood, 1st, sg;
t.fsing: pres, mood, 2nd, m, sg;
t.fsing-fem: pres, mood, 2nd, f, sg;
y.fsing: pres, mood, 3rd, m, sg;
t.fsing: pres, mood, 3rd, f, sg;
t.fdual: pres, mood, 2nd, du;
y.fdual: pres, mood, 3rd, m, du;
t.fdual: pres, mood, 3rd, f, du;
n.fsing: pres, mood, 1st, pl;
t.fplur-masc: pres, mood, 2nd, m, pl;
t.fplur-fem: pres, mood, 2nd, f, pl;
y.fplur-masc: pres, mood, 3rd, m, pl;
y.fplur-fem: pres, mood, 3rd, f, pl;
}
# The "two-form" present uses normal (non-3rd-weak) endings but may
# have two forms of the root, one form vocalic endings (almost all of them)
# and one for consonant endings (only the feminine plural). This
# encompasses 2nd-weak verbs and doubled verbs, and (trivially) strong verbs.
def two-form-pres-indic(formv, formc) {
gen-pres(indic, formv.u, formv.iina, formv.aani, formv.uuna, formc.na)
}
def two-form-pres-subj(formv, formc) {
gen-pres(subj, formv.a, formv.ii, formv.aa, formv.uu, formc.na)
}
# The jussive is different because the base form (fsing) has no ending.
# This means that it may assume the consonant form instead of the vowel
# form, or may have a number of variants (in particular, for doubled
# verbs). So the base form needs to be given explicitly.
def two-form-pres-juss(base, formv, formc) {
gen-pres(juss, base, formv.ii, formv.aa, formv.uu, formc.na)
}
def strong-pres(form) {
two-form-pres-indic(form, form)
two-form-pres-subj(form, form)
two-form-pres-juss(form, form, form)
}
def 2nd-weak-pres(formv, formc) {
two-form-pres-indic(formv, formc)
two-form-pres-subj(formv, formc)
two-form-pres-juss(formc, formv, formc)
}
def doubled-pres(formv, formc) {
two-form-pres-indic(formv, formc)
two-form-pres-subj(formv, formc)
two-form-pres-juss(formc, formv, formc)
two-form-pres-juss(formv.a, formv, formc)
two-form-pres-juss(formv.i, formv, formc)
}
# Verbs whose third radical is a /w/ or a /y/ have all manner of exceptional
# forms; easiest just to list them. In general, there are three types,
# depending on whether the base singular forms end in -aa, -ii, or -uu.
def 3rd-weak-pres-aa(form) {
gen-pres(indic, form.aa, form.ayna, form.ayaani, form.awna, form.ayna)
gen-pres(subj, form.aa, form.ay, form.ayaa, form.aw, form.ayna)
# Note the shortened vowel here.
gen-pres(juss, form.a, form.ay, form.ayaa, form.aw, form.ayna)
}
def 3rd-weak-pres-ii(form) {
gen-pres(indic, form.ii, form.iina, form.iyaani, form.uuna, form.iina)
gen-pres(subj, form.iya, form.ii, form.iyaa, form.uu, form.iina)
# Note the shortened vowel here.
gen-pres(juss, form.i, form.ii, form.iyaa, form.uu, form.iina)
}
def 3rd-weak-pres-uu(form) {
gen-pres(indic, form.uu, form.iina, form.uwaani, form.uuna, form.uuna)
gen-pres(subj, form.uwa, form.ii, form.uwaa, form.uu, form.uuna)
# Note the shortened vowel here.
gen-pres(juss, form.u, form.ii, form.uwaa, form.uu, form.uuna)
}
def 2nd-weak-verb(pastv, props, pastc, presv, presc) {
word pastv: props {
two-form-past(pastv, pastc)
2nd-weak-pres(presv, presc)
}
}
# Note the way that macro calls can be constructed as well. Here, the
# value of PAST_TYPE is the suffix at the end of the macro name.
def 3rd-weak-verb(past_stem, props, past_type, pres_stem, pres_type) {
word past_stem . past_type: props {
3rd-weak-past- . past_type(past_stem)
3rd-weak-pres- . pres_type(pres_stem)
}
}
def strong-verb(past, props, pres) {
word past: props {
strong-past(past)
strong-pres(pres)
}
}
2nd-weak-verb(kaan, TransV(pred=be), kun, akuun, akun)
2nd-weak-verb(naam, IntransV(pred=sleep), nim, anaam, anam)
2nd-weak-verb(qaal, SayV(pred=say), qul, aquul, aqul)
strong-verb(katab, TransV(pred=write), aktub)
strong-verb(dhahab, IntransV(pred=go), adhhab)
# Note that the following verb, which begins with a glottal stop,
# will have a modification made to it in the first-person singular present.
# (See above.)
strong-verb(_akal, IntransV TransV (pred=eat), a_kul)
3rd-weak-verb(ra_, TransV(pred=see), ay, ar, aa)
3rd-weak-verb(_a9T, DitransV(pred=give), ay, u9T, ii)
3rd-weak-verb(laq, TransV(pred=find), ii, alq, aa)
strong-verb(9araf, ThinkV(pred=know), a9rif) # see also 9alam
strong-verb(tafakkar, ThinkV(pred=think), atafakkar)
strong-verb(ta9allam, ThinkV(pred=learn), ata9allam)
family N {
entry: n<2>[X, 3rd, nonres]: X:sem-obj(*);
}
family InterrogPro(Pro) {
entry: s/*(s/n<2>[res]);
entry: s/*(s|n<2>[nonres,nom]);
entry: s/*(s/n<2>[nonres,acc]);
member: maa, man;
}
family Pro {
entry: n<2>[X, nom, def, nonres]: X:sem-obj(*);
member: pro;
}
family Rel {
entry: (n<~2>[CASE,nonres]\n<~2>[nonres])/*(s/n<2>[res]);
entry: (n<~2>[CASE,nonres]\n<~2>[nonres])/*(s|n<2>[nonres,nom]);
entry: (n<~2>[CASE,nonres]\n<~2>[nonres])/*(s/n<2>[nonres,acc]);
member: al-ladhii;
}
family AndConj(Conj) {
entry: n[pl, CASE, STATE] \* n[CASE, STATE] /* n[CASE, STATE];
entry: s$1 \* s$1 /* s$1;
member: wa;
}
family Det(indexRel=det) {
entry: n<2>[X, def, nonres] /^ n<2>[X]: X:sem-obj(<det>*);
member: haadhaa, dhaalik;
}
# good luck on this one! construct even more complicated ones!
#
#ar-rajulu al-ladhii kataba al-kutuba ra_aa wa _a9Taa li binti hu al-kilaaba al-latii akalat sagaayira mudarrisii al-waladi
#"the man that wrote the books saw and gave to his daughter the dogs that ate the cigarettes of the boy's teachers."
# Works, correctly:
#ar-rajulu al-ladhii kataba al-kutuba ra_aa wa _a9Taa li binti hu as-sagaayira al-latii qultu inna al-waladu tafakkara anna al-mar_atu _a9Tat haa li ha_ulaahi al-mudarrisiina
#Bad
#ar-rajula al-ladhii katabat al-kutuba ra_aa wa _a9Taa li binti hu as-sagaayira al-latii qultu inna al-waladu tafakkara anna al-mar_atu _a9Tat haa li ha_ulaahi al-mudarrisiina
#"the man that wrote the books saw and gave to his daughter the cigarettes that I said that the boy thought that the woman gave them to those teachers"
# Fails, correctly:
#ar-rajulu al-ladhii kataba al-kutuba ra_aa wa _a9Taa li binti hu as-sagaayira al-latii qultu inna al-waladu tafakkara anna al-mar_atu _a9Tat hu li ha-ulaahi al-mudarrisiina
# Works:
# ar-rajulu al-ladhii al-waladu _a9Taa as-sagaayira li binti hu dhahaba
# ar-rajulu _a9Taa li binti hu as-sagaayira
# ar-rajulu al-ladhii waladu hu _a9Taa as-sagaayira li al-binti dhahaba
# Won't work:
# ar-rajulu al-ladhii al-waladu _a9Taa li binti hu as-sagaayira dhahaba
# ar-rajulu al-ladhii waladu hu _a9Taa li al-binti as-sagaayira dhahaba
family PossClitic(Cli, indexRel=poss) {
entry: n<~1>[X, def, nonres] \* n<1>[X, cons]: X:sem-obj(<poss>*);
entry: (n<~1>[X, def, nonres] / n<2>[res]) \* n<1>[X, cons]: X:sem-obj(<poss>*);
member: ii, ka, ki, hu, haa, naa, kum, kunna, hum, hunna;
}
family ObjClitic(Cli, indexRel=poss) {
entry: (s$1 | n<3>[nonres]) \ (s$1 / n<2>[nonres] | n<3>[nom,nonres]);
entry: (s$1 / n<~2>[res] | n<3>[nonres]) \ (s$1 / n<2>[nonres] | n<3>[nom,nonres]);
member: nii, ka, ki, hu, haa, naa, kum, kunna, hum, hunna;
}
family Adj(indexRel=adj) {
entry: n<2>[X, NUM, GEND, CASE, STATE] \ n<2>[X]:
X:sem-obj(<adj>*);
}
family Prep-Nom(Prep, indexRel="*NoSem*") {
# The pp<~3> notation generates an 'inheritsFrom' tag rather than
# an 'id' tag for the feature structure.
entry: pp<~3>[lex=*] /< n<3>[gen,nonres];
member: li, fii;
}
family Comp(indexRel="*NoSem*") {
entry: sbar<~1>[lex=*] / s<1>;
member: anna, inna;
}
family IntransV(V) {
entry: s[E] | n<2>[X,NUM,PERS,GEND,non-cons,nonres,nom]:
E:action(* ^ <Actor>X:animate-being);
}
family SayV(V) {
entry: s[E] / sbar[Z, lex=inna] | n<2>[X,NUM,PERS,GEND,non-cons,nonres,nom]:
E:action(* ^ <Actor>X:animate-being ^ <Situation>Z);
}
family ThinkV(V) {
entry: s[E] / sbar[Z, lex=anna] | n<2>[X,NUM,PERS,GEND,non-cons,nonres,nom]:
E:action(* ^ <Actor>X:animate-being ^ <Situation>Z);
}
family TransV(V) {
entry: s[E] / n[Y,acc,nonres] | n<2>[X,NUM,PERS,GEND,non-cons,nonres,nom]:
E:action(* ^ <Actor>X:animate-being ^ <Patient>Y:sem-obj);
}
family DitransV(V) {
# The first slash (on the pp) is marked with a mode allowing backward xcomp.
entry: s[E] /< pp[Z,lex=li] / n[Y,acc,nonres] | n<2>[X,NUM,PERS,GEND,non-cons,nonres,nom]:
E:action(* ^ <Actor>X:animate-being ^ <Patient>Y:sem-obj ^
<Recipient>Z:animate-being) ;
}
testbed {
# different states of subject
rajulun dhahaba: 1;
ar-rajulu dhahaba: 1;
rajulu dhahaba: 0;
# subject-verb agreement
rajulun dhahabuu: 0;
ar-rajulu dhahabuu: 0;
rajulu dhahabuu: 0;
# gender agreement
ar-rajulu dhahaba: 1;
ar-rajulu dhahabat: 0;
al-bintu dhahaba: 0;
al-bintu dhahabat: 1;
# possession
rajulun hu dhahaba: 0;
ar-rajulu hu dhahaba: 0;
rajulu hu dhahaba: 1;
# subject case
ar-rajula dhahaba: 0;
ar-rajuli dhahaba: 0;
# case in construct phrase
_axuu ar-rajuli dhahaba: 1;
_axuu ar-rajula dhahaba: 0;
_axuu ar-rajulu dhahaba: 0;
# construct state in construct phrase
_axun ar-rajuli dhahaba: 0;
al-_axu ar-rajuli dhahaba: 0;
# object case
ar-rajulu ra_aa al-kitaaba: 1;
ar-rajulu ra_aa al-kitaabi: 0;
ar-rajulu ra_aa al-kitaabu: 0;
# preposition case
ar-rajulu _a9Taa al-kitaaba li al-waladi: 1;
ar-rajulu _a9Taa al-kitaaba li al-waladu: 0;
ar-rajulu _a9Taa al-kitaaba li al-walada: 0;
# subcategorization
ar-rajulu ra_aa al-kitaaba li al-waladi: 0;
# backward xcomp
ar-rajulu _a9Taa li al-waladi al-kitaaba: 1;
_a9Taa ar-rajulu li al-waladi al-kitaaba: 1;
# object clitics
ana ra_aytu hu: 1;
ra_aytu hu ana: 1;
ra_aytu ana hu: 0;
hu ra_aytu ana: 0;
hu ana ra_aytu: 0;
huwa ra_aa nii: 1;
huwa ra_aa ii: 0;
huwa ra_aa ana: 0;
ar-rajulu _a9Taa haa li al-waladi: 1;
_a9Taa haa ar-rajulu li al-waladi: 1;
# relative clauses
# "I gave it to the man that the girl saw him"
_a9Taytu haa li ar-rajuli al-ladhii al-bintu ra_at hu: 3;
# "I gave it to the man that the girl saw her"
_a9Taytu haa li ar-rajuli al-ladhii al-bintu ra_at haa: 0;
# "I gave it to the man that the girl saw"
_a9Taytu haa li ar-rajuli al-ladhii al-bintu ra_at: 0;
# "I gave it to the man that the girl saw the boy"
_a9Taytu haa li ar-rajuli al-ladhii al-bintu ra_at al-walada: 0;
}