def var_pair16(arr):
name_to_var = {}
count = 0
for i in arr:
if i not in name_to_var:
name_to_var[i] = 'p' + str(count)
count = count + 1
st = 'MS Dhoni'
temp_strin1 = ''
temp_strin1 += 'player => {'
for i in name_to_var:
temp_strin1 += name_to_var[i]
temp_strin1 += ','
temp_strin1 = temp_strin1[:-1]
temp_strin1 += '} \n'
if st not in name_to_var:
name_to_var[st] = 'p' + str(count)
count = count + 1
s = name_to_var['MS Dhoni']
v = temp_strin1
query = 'player(s)'
l = nltk.LogicParser()
val = nltk.parse_valuation(v)
dom = val.domain
m = nltk.Model(dom, val)
dom = m.domain
g = nltk.Assignment(dom, [('s', name_to_var['MS Dhoni'])])
print "******************************"
print m.evaluate(query, g)
print "******************************"
def make_model_and_answer9(v, query, dt):
val = nltk.parse_valuation(v)
dom = val.domain
m = nltk.Model(dom, val)
g = nltk.Assignment(dom, [])
print m.evaluate(query, g)
def var_pair18(middle, count):
string1 = 'Batsmen => {'
for k in middle:
string1 += k + ','
string1 = string1[:-1]
string1 += '}\n'
v = string1
query = 'Batsmen(x)'
l = nltk.LogicParser()
val = nltk.parse_valuation(v)
dom = val.domain
m = nltk.Model(dom, val)
dom = m.domain
g = nltk.Assignment(dom, [])
fmla1 = l.parse(query)
varnames = m.satisfiers(fmla1, 'x', g)
le = len(varnames)
le = le / count
if le >= 0.8:
print True
else:
print False
def make(v, query, parse, dt):
l = nltk.LogicParser()
var = """
India => i
New Zealand=> n
Match1 => m1
Match2 => m2
Match3 => m3
team => {i,n}
match => {m1,m2,m3}
pomteam => {(m1,i),(m2,n),(m3,i)}
winteam => {(m1,i),(m2,n),(m3,i)}
"""
val = nltk.parse_valuation(v)
#print val
dom = val.domain
m = nltk.Model(dom, val)
dom = m.domain
#print dom
g = nltk.Assignment(dom, [])
#print g
print "************************"
#print m.evaluate('all x.( (match(x) & exists y.(team(y) and (pomteam(x,y) and winteam(x,y)))) | (-match(x)) )', g)
print m.evaluate(query, g)
print "************************"
fmla1 = l.parse(parse)
varnames = m.satisfiers(fmla1, 'x', g)
for i in varnames:
for p, q in dt.iteritems():
if q == i:
print p
def __init__(self, domain, properties, binary_rels, valuation):
self._domain = domain
self._properties = properties
self._binary_rels = binary_rels
self._model = nltk.Model(set(domain), nltk.Valuation(valuation))
self._valuation = valuation
self._preds = dict()
self._pred_sats = dict()
for (pred, sats) in valuation:
self._preds[pred] = sats
if pred in binary_rels:
sat_map_0 = dict()
sat_map_1 = dict()
for sat in sats:
if sat[0] not in sat_map_0:
sat_map_0[sat[0]] = set([])
if sat[1] not in sat_map_1:
sat_map_1[sat[1]] = set([])
sat_map_1[sat[1]].add(sat[0])
sat_map_0[sat[0]].add(sat[1])
self._pred_sats[pred] = (sat_map_0, sat_map_1)
elif pred in properties:
sat_set = set([])
for sat in sats:
sat_set.add(sat)
self._pred_sats[pred] = sat_set
def var_pair13(highrun):
name_to_var = {}
temp_strin3 = 'highrun => {'
for k, v in highrun.iteritems():
for j in v:
temp_strin3 += '('
temp_strin3 += k + ','
temp_strin3 += j + '),'
temp_strin3 = temp_strin3[:-1]
temp_strin3 += '} \n'
v = temp_strin3
query = 'highrun(x,y)'
#parse = 'highrun(Ryder,Southee)'
#return v,query,name_to_var,parse
l = nltk.LogicParser()
val = nltk.parse_valuation(v)
dom = val.domain
m = nltk.Model(dom, val)
dom = m.domain
g = nltk.Assignment(dom, [('x', 'Ryder'), ('y', 'Southee')])
print "******************************"
print m.evaluate(query, g)
print "**************************"
def evaluate_sentences(sents_reps, world):
"""
Evaluates representation of each sentences in the world model.
It translates them to their values: True or False.
Parameters:
sents_reps: dictionary of sentences to list of semantic representations.
world: string that represents entities and sets of relations.
Returns:
dict: a dictionary of sentences to dictionary of semantic representations to values.
"""
val = nltk.Valuation.fromstring(world)
g = nltk.Assignment(val.domain)
m = nltk.Model(val.domain, val)
sents_reps = {
sent: {
str(semrep): m.evaluate(str(semrep), g)
for semrep in sents_reps[sent]
}
for sent in sents_reps
}
return sents_reps
def var_pair19(winteam, tossteam):
name_to_var = {}
count = 0
#print winteam
for i in winteam.values():
if i not in name_to_var:
name_to_var[i] = 't' + str(count)
count += 1
for i in tossteam.values():
if i not in name_to_var:
name_to_var[i] = 't' + str(count)
count += 1
name_to_var['Match1'] = 'm1'
name_to_var['Match2'] = 'm2'
name_to_var['Match3'] = 'm3'
name_to_var['Match4'] = 'm4'
name_to_var['Match5'] = 'm5'
temp_strin1 = ''
for i in name_to_var:
temp_strin1 += i + ' => ' + name_to_var[i] + '\n'
temp_strin4 = 'Match1 => m1\n'
temp_strin4 += 'Match2 => m2\n'
temp_strin4 += 'Match3 => m3\n'
temp_strin4 += 'Match4 => m4\n'
temp_strin4 += 'Match5 => m5\n'
temp_strin4 += 'team => {t0,t1}\n'
temp_strin4 += 'match => {m1,m2,m3,m4,m5}\n'
temp_strin2 = 'winteam => {'
for k, v in winteam.iteritems():
temp_strin2 += '('
temp_strin2 += k + ','
temp_strin2 += name_to_var[v] + '),'
temp_strin2 = temp_strin2[:-1]
temp_strin2 += '} \n'
temp_strin3 = 'tossteam => {'
for k, v in tossteam.iteritems():
temp_strin3 += '('
temp_strin3 += k + ','
temp_strin3 += name_to_var[v] + '),'
temp_strin3 = temp_strin3[:-1]
temp_strin3 += '}'
v = temp_strin1 + temp_strin4 + temp_strin2 + temp_strin3
query = 'all x.( (match(x) & exists y.(team(y) and (tossteam(x,y) and winteam(x,y)))) | (-match(x)) )'
val = nltk.parse_valuation(v)
#print val
dom = val.domain
m = nltk.Model(dom, val)
dom = m.domain
g = nltk.Assignment(dom, [])
print "************************"
print m.evaluate(query, g)
print "************************"
def var_pair15(inn1, inn2):
name_to_var = {}
count = 0
for i in inn1:
if i not in name_to_var:
name_to_var[i] = 'p' + str(count)
count += 1
for i in inn2:
if i not in name_to_var:
name_to_var[i] = 'p' + str(count)
count += 1
temp_strin1 = ''
for i in name_to_var:
temp_strin1 += i + ' => ' + name_to_var[i] + '\n'
temp_strin4 = 'player =>{'
for c in range(count):
temp_strin4 += 'p' + str(c) + ','
temp_strin4 = temp_strin4[:-1]
temp_strin4 += '}\n'
temp_strin2 = 'inn1 => {'
for i in inn1:
temp_strin2 += name_to_var[i] + ','
temp_strin2 = temp_strin2[:-1]
temp_strin2 += '}\n'
temp_strin3 = 'inn2 => {'
for i in inn2:
temp_strin3 += name_to_var[i] + ','
temp_strin3 = temp_strin3[:-1]
temp_strin3 += '}\n'
v = temp_strin1 + temp_strin4 + temp_strin2 + temp_strin3
l = nltk.LogicParser()
val = nltk.parse_valuation(v)
#print val
dom = val.domain
m = nltk.Model(dom, val)
dom = m.domain
#print dom
bowler = name_to_var['RA Jadeja']
g = nltk.Assignment(dom, [('x', bowler)])
#print g
print "************************"
#print m.evaluate('all x.( (match(x) & exists y.(team(y) and (pomteam(x,y) and winteam(x,y)))) | (-match(x)) )', g)
flag1 = m.evaluate(' player(x) and inn1(x) ', g)
flag2 = m.evaluate(' player(x) and inn2(x) ', g)
if (flag1 == True):
print 'Inning 1'
else:
print ' Inning 2'
print "************************"
def make_model_and_answer(v,query):
global quantifier
global quantified
global predicate1
global predicate2
global connector
l = nltk.LogicParser()
val = nltk.parse_valuation(v)
#print 'val:'
#print val
#print 'end val:'
dom = val.domain
#print 'dom:'
#print dom
#print 'end dom:'
model = nltk.Model(dom, val)
#print 'model:'
#print m
#print 'end m:'
g = nltk.Assignment(dom, [])
temp = l.parse('match(x)')
m = model.satisfiers(temp, 'x', g)
temp = l.parse('match(x)')
m1 = model.satisfiers(temp, 'x', g)
temp = l.parse('match(x)')
m2 = model.satisfiers(temp, 'x', g)
#print match
temp = l.parse('country(x)')
c = model.satisfiers(temp, 'x', g)
temp = l.parse('country(x)')
c1 = model.satisfiers(temp, 'x', g)
temp = l.parse('country(x)')
c2 = model.satisfiers(temp, 'x', g)
#print country
temp = l.parse('player(x)')
p = model.satisfiers(temp, 'x', g)
temp = l.parse('player(x)')
p1 = model.satisfiers(temp, 'x', g)
temp = l.parse('player(x)')
p2 = model.satisfiers(temp, 'x', g)
#print player
#query formation
#query = 'all m.exists c1.exists c2.exists p1.exists p2.(mom(m,c1,p1) => win(m,c2))'
print "The anwer for the query is : ",
print model.evaluate(query, g)
def check_condition(items, cont, quantity):
g = nltk.Assignment(folval.domain)
m = nltk.Model(folval.domain, folval)
# Checking if a field has all/any(some) items in it
sent = quantity + ' ' + items + ' are_in ' + cont
results = nltk.evaluate_sents([sent], grammar_file, m, g)[0][0]
if results[2]:
return 'Yes.'
else:
return 'No.'
def check_for_car(input_arr):
# check car locations
input_arr = remove_spaces(input_arr)
g = nltk.Assignment(fol_val.domain)
m = nltk.Model(fol_val.domain, fol_val)
sent = 'some ' + input_arr[1] + ' are_in ' + input_arr[2]
answer = nltk.evaluate_sents([sent], grammar_file, m, g)[0][0]
if answer[2]:
print("Your", input_arr[1], "is in", input_arr[2])
else:
print("Your", input_arr[1], "is not in", input_arr[2])
def is_all_cards_in_zone(self, location_input):
g = nltk.Assignment(self.valuation.domain)
m = nltk.Model(self.valuation.domain, self.valuation)
location = self.translate_location(location_input)
if location is None:
print("That doesn't make sense :(")
return
sent = "all card are_in " + location
results = nltk.evaluate_sents([sent], self.grammar_file, m, g)[0][0]
if results[2] == True:
print("Yes.")
else:
print("No.")
def get_cards_in_zone(self, location):
g = nltk.Assignment(self.valuation.domain)
m = nltk.Model(self.valuation.domain, self.valuation)
e = nltk.Expression.fromstring("be_in(x," + location + ")")
card_names = m.satisfiers(e, "x", g)
cards = {}
# find satisfying objects in the valuation dictionary
for card in card_names:
card_name = self.decode_card_name(card)
if card_name not in cards:
cards[card_name] = 1
else:
cards[card_name] += 1
return cards
def logic_parser():
lp = nltk.LogicParser()
SnF = lp.parse('SnF')
NotFnS = lp.parse('-FnS')
R = lp.parse('SnF -> -FnS')
# prover = nltk.Prover9()
# print prover.prove(NotFnS, [SnF, R])
val = nltk.Valuation([('P', True), ('Q', True), ('R', False)])
dom = set([])
g = nltk.Assignment(dom)
m = nltk.Model(dom, val)
print "eval(P&Q)=", m.evaluate('(P & Q)', g)
print "eval -(P&Q)=", m.evaluate('-(P & Q)', g)
print "eval(P&R)=", m.evaluate('(P & R)', g)
print "eval(-(P|R))=", m.evaluate('-(P | R)', g)
def personToLocation(person):
try:
g = nltk.Assignment(folval.domain)
m = nltk.Model(folval.domain, folval)
e = nltk.Expression.fromstring("be_in(" + person + ",x)")
sat = m.satisfiers(e, "x", g)
if len(sat) != 0:
sol = folval.items()
for i in sol:
if i[1] in sat and i[0].isalpha():
return (i[0])
else:
return person
except:
return person
def __init__(self, table, grammar_file_path):
(entities, events, beatat,
tournament_matches_metadata) = self.__parse_table(table)
self.tournament_matches_metadata = tournament_matches_metadata
domain_string = self.__constructDomainString(entities, events, beatat)
grammar_string = self.__constructGrammarString(grammar_file_path,
entities, events)
val = nltk.Valuation.fromstring(domain_string)
self.assignment = nltk.Assignment(val.domain)
self.model = nltk.Model(val.domain, val)
self.grammar = nltk.grammar.FeatureGrammar.fromstring(grammar_string)
def var_pair17(bowlplayer):
string4 = 'bowlplayer => {'
for k, v in bowlplayer.iteritems():
for i in v:
string4 += '(' + k + ',' + i + '),'
string4 = string4[:-1]
string4 += '}\n'
v = string4
val = nltk.parse_valuation(v)
dom = val.domain
m = nltk.Model(dom, val)
dom = m.domain
g = nltk.Assignment(dom, [('x', 'RA Jadeja'), ('y', 'I Sharma')])
print "***********************************************"
print m.evaluate('bowlplayer(x,y)', g)
print "***********************************************"
def truth_model():
domain = set(['b', 'o', 'c'])
v = """
bertie => b
olive => o
cyril => c
boy => {b}
girl => {o}
dog => {c}
walk => {o, c}
see => {(b,o), (c,b), (o,c)}
"""
val = nltk.parse_valuation(v)
print val
print('o', 'c') in val["see"]
print('b', ) in val["boy"]
g = nltk.Assignment(domain, [('x', 'o'), ('y', 'c')])
model = nltk.Model(domain, val)
print "model.evaluate=", model.evaluate("see(olive,y)", g)
def get_all_values(key):
try:
# Creating the nltk expression and inserting the given key in it
g = nltk.Assignment(folval.domain)
m = nltk.Model(folval.domain, folval)
e = nltk.Expression.fromstring("be_in(x," + key + ")")
# Checking if the data satisfies the given expression
sat = m.satisfiers(e, "x", g)
res = ''
if len(sat) == 0:
res = 'None'
else:
# If there are results, add them 1 by 1 to a string
# and separate them with commas
for i in sat:
res += i + ', '
res = res[:-2]
return res.capitalize()
except:
print(error_msg)
def check_garage(input_arr):
# check garage
input_arr = remove_spaces(input_arr)
g = nltk.Assignment(fol_val.domain)
m = nltk.Model(fol_val.domain, fol_val)
e = nltk.Expression.fromstring("be_in(x," + input_arr[1] + ")")
sat = m.satisfiers(e, "x", g)
if len(sat) == 0:
print("There is nothing parked here.")
else:
# find satisfying objects in the valuation dictionary,
# and print their type names
sol = fol_val.values()
for so in sat:
for k, v in fol_val.items():
if len(v) > 0:
vl = list(v)
if len(vl[0]) == 1:
for i in vl:
if i[0] == so:
print("There is a", k, "parked here")
break
def var_pair11(match1):
string1 = 'play1 => {'
for i in match1['play1']:
string1 += i + ','
string1 = string1[:-1]
string1 += '}\n'
string1 += 'play2 => {'
for i in match1['play2']:
string1 += i + ','
string1 = string1[:-1]
string1 += '}\n'
string1 += 'play3 => {'
for i in match1['play3']:
string1 += i + ','
string1 = string1[:-1]
string1 += '}\n'
string1 += 'play4 => {'
for i in match1['play4']:
string1 += i + ','
string1 = string1[:-1]
string1 += '}\n'
string1 += 'play5 => {'
for i in match1['play5']:
string1 += i + ','
string1 = string1[:-1]
string1 += '}\n'
query = 'play1(x) and play2(x) and play3(x) and play4(x) and play5(x)'
l = nltk.LogicParser()
val = nltk.parse_valuation(string1)
dom = val.domain
m = nltk.Model(dom, val)
dom = m.domain
g = nltk.Assignment(dom, [])
fmla1 = l.parse(query)
print m.satisfiers(fmla1, 'x', g)
def var_pair14(mop):
name_to_var = {}
string2 = 'player => {'
for i in mop.values():
string2 += i + ','
string2 = string2[:-1]
string2 += '}\n'
name_to_var['Match1'] = 'm1'
name_to_var['Match2'] = 'm2'
name_to_var['Match3'] = 'm3'
name_to_var['Match4'] = 'm4'
name_to_var['Match5'] = 'm5'
string3 = 'Match1 => m1\nMatch2 => m2\nMatch3 => m3\nMatch4 => m4\nMatch5 => m5\n'
string3 += 'match => {m1,m2,m3,m4,m5}\n'
string3 += 'equal => {(m1,m1),(m2,m2),(m3,m3),(m4,m4),(m5,m5)}\n'
string4 = 'mop => {'
for i in mop:
string4 += '(' + i + ',' + mop[i] + '),'
string4 = string4[:-1]
string4 += '}\n'
v = ''
v = string2 + string3 + string4
query = 'exists x. exists y. exists z.(match(x) and match(y) and player(z) and mop(x,z) and mop(y,z) and -equal(x,y))'
val = nltk.parse_valuation(v)
#print val
dom = val.domain
m = nltk.Model(dom, val)
dom = m.domain
g = nltk.Assignment(dom, [])
print "************************"
print m.evaluate(query, g)
print "************************"
def var_pair12(wideplayer):
string4 = 'wideplayer => {'
for k, v in wideplayer.iteritems():
for i in v:
string4 += '('
string4 += k + ','
string4 += i + '),'
string4 = string4[:-1]
string4 += '}'
v = ''
v = string4
#print v
#query='wideplayer(I Sharma,RA Jadeja)'
parse = ''
val = nltk.parse_valuation(v)
#print val
dom = val.domain
m = nltk.Model(dom, val)
dom = m.domain
g = nltk.Assignment(dom, [('x', 'I Sharma'), ('y', 'RA Jadeja')])
print "************************"
print m.evaluate('wideplayer(x,y)', g)
print "************************"
folval[params[1]].clear()
folval[params[1]].add((o,)) #insert type of ingredient information
if len(folval["be_in"]) == 1: #clean up if necessary
if ('',) in folval["be_in"]:
folval["be_in"].clear()
folval["be_in"].add((o, folval[recipe])) #insert location
print("Bot: Added!")
elif cmd == 5: #Are there any x in y
if folval.__contains__(params[1]) == False:
print("Bot: Sorry but the ingredient does not exist")
else:
if params[2] not in recipeList:
print("Bot: The recipe does not exist")
else:
g = nltk.Assignment(folval.domain)
m = nltk.Model(folval.domain, folval)
recipe = "recipe" + str(recipeList.index(params[2]))
sent = 'some ' + params[1] + ' are_in ' + recipe
results = nltk.evaluate_sents([sent], grammar_file, m, g)[0][0]
if results[2] == True:
print("Yes.")
else:
print("No.")
elif cmd == 6: # Are all x in y
if folval.__contains__(params[1]) == False:
print("Bot: Sorry but the ingredient does not exist")
else:
if params[2] not in recipeList:
print("Bot: The recipe does not exist")
else:
g = nltk.Assignment(folval.domain)
lp = nltk.sem.Expression.fromstring
SnF = read_expr('SnF')
NotFnS = read_expr('-FnS')
R = read_expr('SnF -> -FnS')
prover = nltk.Prover9()
prover.config_prover9(r'D:\Program Files\LADR1007B-win\bin')
prover.prove(NotFnS, [SnF, R])
val = nltk.Valuation([('P', True), ('Q', True), ('R', False)])
val['P']
dom = set()
g = nltk.Assignment(dom)
m = nltk.Model(dom, val)
print(m.evaluate('(P & Q)', g))
print(m.evaluate('-(P & Q)', g))
print(m.evaluate('(P & R)', g))
print(m.evaluate('(P | R)', g))
##一阶逻辑
read_expr = nltk.sem.Expression.fromstring
expr = read_expr('walk(angus)', type_check=True)
expr.argument
expr.argument.type
expr.function
one person => 1
like => {(a, s), (s, j), (c, a), (c, j), (c, d), (c, n), (c, p), (c, s), (c, b), (c, m), (c, c), (c, i), (c, 1) }
love => {(a, d), (d, a), (m, p), (b, s)}
smile => {(n, p)}
cough_sneeze => {s}
coughed_sneezed => {n}
sleep => {1}
"""
val = nltk.Valuation.fromstring(v)
print(val)
print("quick check 1: ", ('a', 's') in val['like'])
print("quick check 2: ", ('j', 'd') not in val['like'])
m = nltk.Model(dom, val)
def assign_g(g_variables):
return nltk.Assignment(dom, g_variables)
# print("angus, dog: ", m.evaluate('love(angus, dog)', g))
# smile = m.evaluate('exists x.(coughed_sneezed(x) & smile(x, y) & -love(x, y) )', g)
# print("smile:", smile)
# a
ga = assign_g([('x', 'a'), ('y', 'j')]) # angus and julia
ex_a = m.evaluate('exists z.(like(x, z)) & exists z.(like(z, y))', ga)
print("(a): ", ex_a)
# 有效的论证：所有的前提为真时，结论都为真的论证
read_expr = nltk.sem.Expression.fromstring
SnF = read_expr('SnF')
NotFns = read_expr('-FnS')
R = read_expr('SnF-> -FnS')
prover = nltk.Prover9()
prover.prove(NotFns, [SnF, R])
# 为每个命题符号分配一个值，通过查询确定布尔运算符的含义，并用它们替代这些公式的组成成分的值，来计算合成公式的值
# 配对的链表初始化估值，每个配对由语义符号和语义值组成。
val = nltk.Valuation([('P', True), ('Q', True), ('R', False)])
val['P']
# dom和g参数都被忽略了，后面会用于更加复杂的模型
dom = set()
grammar1 = nltk.Assignment(dom)
model1 = nltk.Model(dom, val)
print(model1.evaluate('(P&Q)', grammar1))
print(model1.evaluate('-(P&Q)', grammar1))
print(model1.evaluate('(P&R)', grammar1))
print(model1.evaluate('(P|R)', grammar1))
# 3. 一阶逻辑
# 通过翻译自然语言表达式成为一阶逻辑是计算语义的不错的选择
# 3.1 语法
# 一阶逻辑保留了所有命题逻辑的布尔运算符。
# 命题被分析成谓词和参数，接近于自然语言的结构的距离
# 一阶逻辑的标准构造规则的术语：独立变量、独立常量、带不同数量的参数的谓词（一元谓词、二元谓词）
# 表达式被称为非逻辑常量；逻辑觉得在一阶逻辑的每个模型中的解释总是相同的。
# 通过为表达式指定类型可以检查一阶逻辑表达式的语法结构。基本类型：e是实体类型；t是公式类型，即有真值的表达式类型。
# 给定两种基本类型，可以形成函数表达式的复杂类型。
# 信号，作为字典实现与非逻辑变量类型之间的关联。
def var_pair20(winteam):
name_to_var = {}
name_to_var['Match1'] = 'm1'
name_to_var['Match2'] = 'm2'
name_to_var['Match3'] = 'm3'
name_to_var['Match4'] = 'm4'
name_to_var['Match5'] = 'm5'
temp_strin2 = ''
for i in name_to_var:
temp_strin2 += i + ' => ' + name_to_var[i] + '\n'
temp_strin3 = 'winteam => {'
for k, v in winteam.iteritems():
temp_strin3 += '('
temp_strin3 += k + ','
temp_strin3 += v + '),'
temp_strin3 = temp_strin3[:-1]
temp_strin3 += '} \n'
temp_strin4 = 'Match1 => m1\n'
temp_strin4 += 'Match2 => m2\n'
temp_strin4 += 'Match3 => m3\n'
temp_strin4 += 'Match4 => m4\n'
temp_strin4 += 'Match5 => m5\n'
temp_strin4 += 'match => {m1,m2,m3,m4,m5}\n'
v = temp_strin3 + temp_strin4 + temp_strin2
parse1 = 'match(x) & winteam(x,i)'
parse2 = 'match(x) & winteam(x,n) | -match(x)'
#return v,query,name_to_var,parse
l = nltk.LogicParser()
val = nltk.parse_valuation(v)
dom = val.domain
m = nltk.Model(dom, val)
dom = m.domain
g = nltk.Assignment(dom, [('i', 'India'), ('n', 'New Zealand')])
print "******************************"
fmla1 = l.parse(parse1)
varnames1 = m.satisfiers(fmla1, 'x', g)
fmla2 = l.parse(parse2)
varnames2 = m.satisfiers(fmla2, 'x', g)
#print varnames1
#print varnames2
count1 = 0
count2 = 0
for i in varnames1:
for p, q in winteam.iteritems():
if p == i:
count1 = count1 + 1
for i in varnames2:
for p, q in winteam.iteritems():
if p == i:
count2 = count2 + 1
if count1 > count2:
print 'India'
else:
print 'New Zealand'
print "**************************"
female => {f}
detective => {b}
bar => {c}
arrest => {(b,a)}
interview => {(b,c,a)}
male => {a}
waiter => {a,f}
in => {(a,c)}
"""
# Load model valuations
val = nltk.Valuation.fromstring(V)
# Initialize assignment g
g = nltk.Assignment(val.domain)
# Create model
m = nltk.Model(val.domain, val)
parser = nltk.parse.FeatureChartParser(grammar_exam)
def nltk_tag_to_wordnet_tag(nltk_tag):
if nltk_tag.startswith('J'):
return wordnet.ADJ
elif nltk_tag.startswith('V'):
return wordnet.VERB
elif nltk_tag.startswith('N'):
return wordnet.NOUN
elif nltk_tag.startswith('R'):
return wordnet.ADV
else:
return None
def preprocess_sentence(sentence):
