Lab 3 benim_lab_rules.py

from semantic import *
from parser.feature import *

sem = SemanticRuleSet()
identity = lambda x: x

### Rules ###

# Start rules
sem.add("Start -> S", lambda s: processSentence(s))
sem.add("Start -> Q[wh +]", lambda q: whQuestion(q))
sem.add("Start -> Q[wh -]", lambda q: ynQuestion(q))

# Declarative sentence
sem.add("S -> NP[wh -] VP", lambda np, vp: vp(np))

# Yes-no question
sem.add("Q[wh -] -> Do_Modal NP[wh -] VBAR[fin +]",
lambda dm, np, vbar: dm(vbar(np)))

# Where did ...
sem.add("Q[wh +] -> AdvP[wh +] Q[wh -]",
lambda advp, q:
q.addFeature(str(advp.getFeature("type").value()),
advp.getFeature("var").value()))

sem.add("Q[wh +] -> NP[wh +] VP",
lambda np, vp: vp(np))

sem.add("Q[wh +] -> NP[wh +] Q/NP",
lambda np, q: q(np))

sem.add("Q/NP -> Do_Modal NP VBAR[fin +]/NP",
lambda dm, np, vbar: lambda object: dm(vbar(np, object)))

sem.add("VBAR[fin +]/NP -> V2[tense -] NP/NP",
lambda v2, e: v2)

sem.add("VBAR[fin +]/NP -> V3[tense -] NP PP.dat/NP",
lambda v3, np, pp: lambda subj, beneficiary: v3(subj, beneficiary, np))

sem.add("VBAR[fin +]/NP -> V3[tense -] NP/NP PP.dat",
lambda v3, np, pp: lambda subj, patient: v3(subj, pp, patient))

sem.add("VBAR[fin +]/NP -> V3[tense -] NP/NP NP",
lambda v3, np1, np2: lambda subj, patient: v3(subj, np2, patient))

# NP
sem.add("NP[pro -, wh -] -> Name", identity)
sem.add("NP[pro -, wh -] -> Det AP* N", lambda det, apstar, n: n(det, apstar))
sem.add("NP[pro -, wh -] -> AP* N[mass +]", lambda apstar, nmass: nmass(apstar))

# AdvP[wh +]
#sem.add("NP[wh +] -> NP[pro +, wh +]", identity)
sem.add("AdvP[wh +] -> Adv[wh +]", identity)

# AP
sem.add("AP* -> AP* AP", lambda apstar, ap: C(ap, mod=apstar))
sem.add("AP* ->", lambda: StarCategory())
sem.add("AP -> A", identity)

# VP
sem.add("VP -> V+args", lambda v: lambda subj: v(subj))
sem.add("VP -> Do_Modal VBAR[fin +]",
lambda dm, vbar: lambda subj: dm(vbar(subj)))
sem.add("V+args -> Be[tense +] V.part[form V2]",
lambda be, vpart: lambda subj: be(vpart(Category.parse("Object"), subj)))
sem.add("V+args -> Be[tense +] V.part[form V2] PP.by",
lambda be, vpart, pp: lambda subj: be(vpart(pp, subj)))
sem.add("V+args -> V1[tense +]", lambda v1: lambda subj: v1(subj))
sem.add("V+args -> V1[tense +] PP", lambda v1, pp: lambda subj: pp(v1(subj)))
sem.add("VBAR[fin +] -> V1[tense -]", lambda v1: lambda subj: v1(subj))
sem.add("V+args -> V2[tense +] NP", lambda v2, np: lambda subj: v2(subj, np))
sem.add("V+args -> V2[tense +] NP[wh -] PP",
lambda v2, np, pp: lambda subj: pp(v2(subj, np)))
sem.add("VBAR[fin +] -> V2[tense -] NP[wh -]",
lambda v2, np: lambda subj: v2(subj, np))
sem.add("V+args -> V3[tense +] NP[wh -] PP.dat",
lambda v3, np, pp: lambda subj: v3(subj, pp, np))
sem.add("V+args -> V3[tense +] NP[wh -] NP[wh -]",
lambda v3, np1, np2: lambda subj: v3(subj, np1, np2))
sem.add("VBAR[fin +] -> V3[tense -] NP[wh -] PP.dat",
lambda v3, np, pp: lambda subj: v3(subj, pp, np))
sem.add("VBAR[fin +] -> V3[tense -] NP[wh -] NP[wh -]",
lambda v3, np1, np2: lambda subj: v3(subj, np1, np2))
sem.add("V+args -> V4[tense +] NP[wh -] PP[loc +]",
lambda v4, np, pp: lambda subj: v4(subj, np, pp))
sem.add("V+args -> V5[tense +] VBAR[fin -]",
lambda v5, vbar: lambda subj: v5(subj, vbar(subj)))
sem.add("V+args -> V6[tense +] NP[wh -] VBAR[fin -]",
lambda v6, np, vbar: lambda subj: v6(subj, np, vbar(np)))
sem.add("V+args -> V8[tense +] SBAR.that[fact -]",
lambda v8, sbar: lambda subj: v8(subj, sbar))
sem.add("V+args -> V9[tense +] SBAR.that[fact +]",
lambda v9, sbar: lambda subj: v9(subj, sbar))
sem.add("V+args -> V10[tense +] AP.pred",
lambda v10, ap: lambda subj: v10(subj, ap))
sem.add("V+args -> V11[tense +] Q_emb",
lambda v11, qemb: lambda subj: v11(subj, qemb))
sem.add("V+args -> V12[tense +] SBAR.for",
lambda v12, sbar: lambda subj: v12(subj, sbar))

# VBAR[fin -]
sem.add("VBAR[fin -] -> To VBAR[fin +]",
lambda to, vbar: lambda subj: vbar(subj))
# Q_emb
sem.add("Q_emb -> SBAR.comp[wh +]", identity)

# AP.pred
sem.add("AP.pred -> A.pred PP", lambda a, ppstar: a(ppstar))

# PP
sem.add("PP[loc ?x] -> P[loc ?x] NP[wh -]", lambda p, np: p(np))
sem.add("PP -> P NP", lambda p, np: p(np))
sem.add("PP.dat -> P.dat NP", lambda p, np: p(np))
sem.add("PP.by -> P.by NP", lambda p, np: p(np))

# SBAR.that
sem.add("SBAR.that -> That S", lambda that, s: s)

# SBAR.comp[wh +]
sem.add("SBAR.comp[wh +] -> Comp[wh +] S", lambda comp, s: s)

# SBAR.for
sem.add("SBAR.for -> For NP[wh -] VBAR[fin -]",
lambda for_, np, vbar: vbar(np))

# Do or Modal
sem.add("Do_Modal -> Do[tense +]", identity)
sem.add("Do_Modal -> Modal", identity)

# Empty slash rules
sem.add("NP/NP ->", lambda: None)
sem.add("PP.dat/NP -> P.dat NP/NP", lambda p, np: None)

### Lexicon ###

# Names
sem.addMatch("Name -> *", lambda name: C("Object", name=name))

sem.addLexicon("Name",
['Bob', 'Bill', 'Fido', 'Fred', 'icecream', 'Jane', 'John', 'Mary', 'Poirot', 'Rusty'])

# Common nouns
sem.addMatch("N[mass -] -> *", lambda word: lambda det, apstar: C("Object", type=word, definite=det, mod=apstar))
sem.addMatch("N[mass +] -> *", lambda word: lambda det, apstar: C("Object", type=word, definite=False, number='mass',
mod=apstar))

sem.addLexicon("N[mass -, number singular]",
['book', 'cadillac', 'car', 'case', 'city', 'communist', 'conference',
'corner', 'dog', 'eggplant', 'exam', 'fact', 'guy', 'kennel', 'letter',
'man', 'park', 'pencil', 'pot', 'room', 'table', 'tax', 'theory',
'tree', 'tune', 'volume', 'werewolf', 'woman'])
sem.addLexicon("N[mass -, number plural]",
['books', 'cats', 'cities', 'cows', 'drugs', 'friends', 'horses',
'keys', 'mets', 'redsox', 'teams', 'volumes', 'years'])
sem.addLexicon("N[mass +]", ['icecream'])
sem.add("Det -> 'the'", lambda word: True)
sem.add("Det -> 'this'", lambda word: True)
sem.add("Det -> 'a'", lambda word: False)
sem.add("Det -> 'an'", lambda word: False)

# wh-words
sem.addMatch("NP[pro +, wh +] -> *", lambda word: VariableValue(word))
sem.addLexicon("NP[pro +, wh +]", ['who', 'what'])
sem.add("Adv[wh +] -> 'where'", lambda word: C('Adverb', type='locative', var=VariableValue("where")))

def addVerb(form, root, past, present, ppart=None):
global sem
if ppart is None: ppart = past
(pos, proc) = form
sem.add(CFGProduction(pos.mix(C(None, tense=False)), root),
proc(root, False))
sem.add(CFGProduction(pos.mix(C(None, tense=True)), past),
proc(root, "past"))
sem.add(CFGProduction(pos.mix(C(None, tense=True)), present),
proc(root, "present"))
sem.add(CFGProduction(C("V.part", form=pos), ppart),
proc(root, "past-participle"))

v1form = (C("V1"),
lambda root, tense: lambda word: lambda agent: C("Event", action=root, agent=agent, tense=tense))

v2form = (C("V2"),
lambda root, tense: lambda word: lambda agent, patient: C("Event", action=root, agent=agent, patient=patient,
tense=tense))

v3form = (C("V3"),
lambda root, tense: lambda word: lambda agent, beneficiary, patient: C("Event", action=root, agent=agent, patient=patient,
beneficiary=beneficiary, tense=tense))

addVerb(v1form, 'come', 'came', 'comes', 'come')
addVerb(v1form, 'drive', 'drove', 'drives', 'driven')
addVerb(v1form, 'eat', 'ate', 'eats', 'eaten')
addVerb(v1form, 'return', 'returned', 'returns')
addVerb(v1form, 'sing', 'sang', 'sings', 'sung')
addVerb(v1form, 'sleep', 'slept', 'sleeps')
addVerb(v1form, 'talk', 'talked', 'talks')

addVerb(v2form, 'eat', 'ate', 'eats', 'eaten')
addVerb(v2form, 'buy', 'bought', 'buys')
addVerb(v2form, 'catch', 'caught', 'catches')
addVerb(v2form, 'chase', 'chased', 'chases')
addVerb(v2form, 'compute', 'computed', 'computes')
addVerb(v2form, 'drive', 'drove', 'drives', 'driven')
addVerb(v2form, 'find', 'found', 'finds')
addVerb(v2form, 'hate', 'hated', 'hates')
addVerb(v2form, 'keep', 'kept', 'keeps')
addVerb(v2form, 'kill', 'killed', 'kills')
addVerb(v2form, 'like', 'liked', 'likes')
addVerb(v2form, 'love', 'loved', 'loves')
addVerb(v2form, 'make', 'made', 'makes')
addVerb(v2form, 'pass', 'passed', 'passes')
addVerb(v2form, 'please', 'pleased', 'pleases')
addVerb(v2form, 'sing', 'sang', 'sings', 'sung')
addVerb(v2form, 'see', 'saw', 'sees', 'seen')
addVerb(v2form, 'support', 'supported', 'supports')
addVerb(v2form, 'surprise', 'surprised', 'surprises')
addVerb(v2form, 'visit', 'visited', 'visits')
addVerb(v2form, 'kiss', 'kissed', 'kisses')
addVerb(v3form, 'give', 'gave', 'gives', 'given')

sem.add("P[loc -] -> 'in'",
lambda word: lambda location: lambda frame: frame.addFeature("locative", C("Place", relation="in",
location=location)))

sem.add("P[loc -] -> 'under'",
lambda word: lambda location: lambda frame: frame.addFeature("locative", C(None, relation="under",
location=location)))

sem.add("P[loc +] -> 'on'",
lambda word: lambda location: C("locative", C(None, relation="on",
location=location)))

sem.add("P[loc -] -> 'of'",
lambda word: lambda source: lambda frame: frame.addFeature("source", source))

sem.add("P.dat -> 'to'",
lambda word: identity)

sem.add("P.by -> 'by'",
lambda word: identity)

# Adjectives
sem.addMatch("A -> *", lambda word: C(word))
sem.addLexicon("A", ['rabid', 'raw', 'smart', 'red', 'blue', 'green', 'yellow'])

sem.add("A.pred -> 'suspicious'", lambda word: lambda source: C("suspicious", source=source))

# Aux and Modal
sem.add("Do[tense +] -> 'did'",
lambda word: lambda verb_frame: verb_frame.addFeature("tense", "past"))

sem.add("Do[tense +] -> 'does'",
lambda word: lambda verb_frame: verb_frame.addFeature("tense", "present"))

sem.add("Be[tense +] -> 'is'",
lambda word: lambda verb_frame: verb_frame.addFeature("tense", "present"))

sem.add("Be[tense +] -> 'was'",
lambda word: lambda verb_frame: verb_frame.addFeature("tense", "past"))

sem.add("Modal -> 'can'",
lambda word: lambda verb_frame: verb_frame.addFeature("mood", "can").addFeature("tense", "present"))

sem.add("To -> 'to'", lambda word: lambda: None)
sem.add("That -> 'that'", lambda word: lambda: None)
sem.add("Comp[wh +] -> 'whether'", lambda word: lambda: None)
sem.add("NP[wh -, pro +] -> 'somebody'", lambda word: C("Object"))

### Sentence processing ###

def processSentence(data):
sem.learned.add(data)
return "Okay."

def ynQuestion(data):
if sem.learned.match(data) is not None: return "Yes."
else: return "No."

def whQuestion(data):
vars = sem.learned.matchVar(data)
if vars is None: return "I don't know."
else:
if len(vars.keys()) == 1:
return translate(vars.values()[0])
else:
return translate(sem.learned.match(data))

def translate(data):
if data.symbol() == "Object":
name = data.getFeature("name").value()
definite = data.getFeature("definite").value()
plural = data.getFeature("plural").value()
type = data.getFeature("type").value()
mod = translateModifier(data.getFeature("mod").value())
desc = "%s%s" % (mod, type)
if name != Category.null():
return name
elif type != Category.null():
if definite: return "the %s" % desc
else:
if plural: return "some %s" % desc
else: return "a %s" % desc
else: return "something"
elif data.symbol() == "Place":
relation = data.getFeature("relation").value()
location = translate(data.getFeature("location").value())
return "%s %s" % (relation, location)
else: return repr(data)

def translateModifier(data):
if data == Category.null(): return ""
else: return "%s%s " % (translateModifier(data.getFeature("mod").value()), data.symbol())