def test_satisfiersNinth(self):
# arrange
v = """
bruce => b
cyril => c
elspeth => e
julia => j
matthew => m
person => {b, e, j, m}
admire => {(j, b), (b, b), (m, e), (e, m), (c, a)}
"""
lp = nltk.LogicParser()
val = nltk.parse_valuation(v)
dom = val.domain
m = nltk.Model(dom, val)
g = nltk.Assignment(dom)
fmla = lp.parse("(person(y) & all x.((x = bruce | x = julia) -> admire(x, y)))")
# act
# there exists a person that admires another person
res = m.satisfiers(fmla, 'y', g)
# assert
self.assertTrue(len(res) == 1)
self.assertTrue('b' in res)
def test_purgeSecond(self):
# arrange
v = """
bertie => b
olive => o
cyril => c
boy => {b}
girl => {o}
dog => {c}
walk => {o, c}
see => {(b, o), (c, b), (o, c)}
"""
dom = set(['b', 'o', 'c'])
val = nltk.parse_valuation(v)
# act
g = nltk.Assignment(dom, [('x', 'o'), ('y', 'c')])
m = nltk.Model(dom, val)
g.purge()
# assert
# this is false because see only accepts b, o | c, b | o, c
# y is mapped to c, so see(y, x) really is checking see(c, o)
# which isn't a valid assignment
self.assertTrue(m.evaluate("see(olive, y)", g) == "Undefined")
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 test_satisfiersThird(self):
# arrange
v = """
bertie => b
olive => o
cyril => c
boy => {b}
girl => {o}
dog => {c}
walk => {o, c}
see => {(b, o), (c, b), (o, c)}
"""
lp = nltk.LogicParser()
dom = set(['b', 'o', 'c'])
val = nltk.parse_valuation(v)
g = nltk.Assignment(dom, [('x', 'o'), ('y', 'c')])
m = nltk.Model(dom, val)
g.purge()
fmla1 = lp.parse('walk(x) -> girl(x)')
# act
res = m.satisfiers(fmla1, 'x', g)
# assert
# this checks if there is someone who walks
# but is not a girl
# or someone who is not a girl and doesn't walk
self.assertTrue('o' in res)
self.assertTrue('b' in res)
def test_satisfiersSeventh(self):
# arrange
v = """
bruce => b
cyril => c
elspeth => e
julia => j
matthew => m
person => {b, e, j, m}
admire => {(j, b), (b, b), (m, e), (e, m), (c, a)}
"""
lp = nltk.LogicParser()
val = nltk.parse_valuation(v)
dom = val.domain
m = nltk.Model(dom, val)
g = nltk.Assignment(dom)
fmla = lp.parse("(person(x) -> exists y.(person(y) & admire(x, y)))")
# act
# there exists a person that admires another person
res = m.satisfiers(fmla, 'x', g)
# assert
self.assertTrue("a" in res)
self.assertTrue("j" in res)
self.assertTrue("b" in res)
self.assertTrue("m" in res)
self.assertTrue("e" in res)
self.assertTrue("c" in res)
def test_satisfiersSixth(self):
# arrange
v = """
bertie => b
olive => o
cyril => c
person => {b, o, c}
admire => {(b, o)}
boy => {b}
girl => {o}
dog => {c}
walk => {o, c}
see => {(b, o), (c, b), (o, c)}
"""
lp = nltk.LogicParser()
dom = set(['b', 'o', 'c'])
val = nltk.parse_valuation(v)
g = nltk.Assignment(dom, [('x', 'o'), ('y', 'c')])
m = nltk.Model(dom, val)
g.purge()
# act
# there exists a person that admires another person
res = m.evaluate('exists x.(person(x) -> exists y.(person(y) & admire(x, y)))', g)
# assert
self.assertTrue(res)
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_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 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 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 test_satisfiersFirst(self):
# arrange
v = """
bertie => b
olive => o
cyril => c
boy => {b}
girl => {o}
dog => {c}
walk => {o, c}
see => {(b, o), (c, b), (o, c)}
"""
lp = nltk.LogicParser()
dom = set(['b', 'o', 'c'])
val = nltk.parse_valuation(v)
g = nltk.Assignment(dom, [('x', 'o'), ('y', 'c')])
m = nltk.Model(dom, val)
g.purge()
fmla1 = lp.parse('girl(x) | boy(x)')
# act
res = m.satisfiers(fmla1, 'x', g)
# assert
# this checks to see if in both girl and walk there exist the same person (in this case, o)
self.assertTrue('b' in res)
self.assertTrue('o' in res)
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 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 make_model_and_answer12(s,query): #print s val=nltk.parse_valuation(s) dom=val.domain m=nltk.Model(dom,val) g=nltk.Assignment(dom,[]) #print m print '' print 'Q12. Ishant Sharma bowled more wides than Sir Jadeja' print m.evaluate(query,g)
def make_model_and_answer13(s,query): #print s val=nltk.parse_valuation(s) dom=val.domain m=nltk.Model(dom,val) g=nltk.Assignment(dom,[]) #print m print '' print 'Q13. Southee took more catches than Ryder' print m.evaluate(query,g)
def load_model (self):
self.model = None
self.assignment = None
try:
fn = self.prefix + '-model.txt'
val = parse_valuation(open(fn).read())
self.model = Model(val.domain, val)
self.assignment = Assignment(self.model.domain)
except Exception, e:
print '** Failure loading model: ' + str(e)
def make_model_and_answer8(s,query):
#print s
val=nltk.parse_valuation(s)
dom=val.domain
m=nltk.Model(dom,val)
g=nltk.Assignment(dom,[])
print ''
print 'Q8. Player scored a century but team lost'
print m.evaluate(query,g)
x=nltk.LogicParser()
c1=x.parse('(match(x)) & (exists y.((player(y)) & centurybutlost(x,y)))')
varnames=m.satisfiers(c1,'x',g)
for i in varnames:
print i
def make_model_and_answer6(s,query):
#print s
val=nltk.parse_valuation(s)
dom=val.domain
m=nltk.Model(dom,val)
g=nltk.Assignment(dom,[])
print ''
print 'Q6. Player, who has bowled more than 7 overs and not taken a single wicket in a match for all matches'
print m.evaluate(query,g)
x=nltk.LogicParser()
c1=x.parse('(player(y)) & (exists x.((match(x)) & morethan7overs(x,y) & nowickets(x,y)))')
varnames=m.satisfiers(c1,'y',g)
for i in varnames:
print i
def make_model_and_answer5(s,query):
#print s
val=nltk.parse_valuation(s)
dom=val.domain
m=nltk.Model(dom,val)
g=nltk.Assignment(dom,[])
print ''
print 'Q5. Player, who has scored at least 50 runs and taken at least 1 wicket in a match in the series'
print m.evaluate(query,g)
x=nltk.LogicParser()
c1=x.parse('(player(y)) & (exists x.((match(x)) & morethan50(x,y) & atleast1w(x,y)))')
varnames=m.satisfiers(c1,'y',g)
for i in varnames:
print i
def make_model_and_answer4(s,query):
#print s
val=nltk.parse_valuation(s)
dom=val.domain
m=nltk.Model(dom,val)
g=nltk.Assignment(dom,[])
print ''
print 'Q4. For all matches, at least one player who hit at least one boundary but strike rate < 100'
print m.evaluate(query,g)
x=nltk.LogicParser()
c1=x.parse('(player(y)) & (exists x.((match(x)) & atleast1four(x,y) & strikeratebelow(x,y)))')
varnames=m.satisfiers(c1,'y',g)
for i in varnames:
print i
def make_model_and_answer1(s,query,players):
val=nltk.parse_valuation(s)
dom=val.domain
m=nltk.Model(dom,val)
g=nltk.Assignment(dom,[])
print ''
print 'Q1. Player of match is given to player of winning team'
print m.evaluate(query,g)
x=nltk.LogicParser()
c1=x.parse('(match(x)) & (exists y.((team(y)) & (winplayerteam(x,y) & winteam(x,y))))')
varnames=m.satisfiers(c1,'x',g)
for i in varnames:
print i
def make_model_and_answer3(s,query):
#print s
val=nltk.parse_valuation(s)
dom=val.domain
m=nltk.Model(dom,val)
g=nltk.Assignment(dom,[])
print ''
print 'Q3. Strike rate more than 200 means more sixes than fours'
print m.evaluate(query,g)
x=nltk.LogicParser()
c1=x.parse('(match(x)) & (exists y.((player(y)) & (strikerate(x,y) -> more6than4(x,y))))')
varnames=m.satisfiers(c1,'x',g)
for i in varnames:
print i
def make_model_and_answer2(s,query):
#print s
val=nltk.parse_valuation(s)
dom=val.domain
m=nltk.Model(dom,val)
g=nltk.Assignment(dom,[])
print ''
print 'Q2. At least one duck for losing team'
print m.evaluate(query,g)
x=nltk.LogicParser()
c1=x.parse('(match(x)) & (exists y.((team(y)) & losingteam(x,y) & ducks(x,y)))')
varnames=m.satisfiers(c1,'x',g)
for i in varnames:
print i
def make_model_and_answer10(s,query):
#print s
val=nltk.parse_valuation(s)
dom=val.domain
m=nltk.Model(dom,val)
g=nltk.Assignment(dom,[])
#print m
print ''
print 'Q10. There is a player, who is less than 26 years of age, has scored more than 250 runs in the series and not a single duck'
print m.evaluate(query,g)
x=nltk.LogicParser()
c1=x.parse('(player(x)) & (-ducks(x)) & (morethan250(x))')
varnames=m.satisfiers(c1,'x',g)
for i in varnames:
print i
def make_model_and_answer11(s,query):
#print s
val=nltk.parse_valuation(s)
dom=val.domain
m=nltk.Model(dom,val)
g=nltk.Assignment(dom,[])
#print m
print ''
print 'Q11. Players, who have played in all matches'
#print m.evaluate(query,g)
x=nltk.LogicParser()
c1=x.parse('(player(x)) & (all y.((match(y) & pnm(y,x)) | (-match(y))))')
varnames=m.satisfiers(c1,'x',g)
for i in varnames:
print i
def make_model_and_answer9(s,query):
#print s
val=nltk.parse_valuation(s)
dom=val.domain
m=nltk.Model(dom,val)
g=nltk.Assignment(dom,[])
#print m
print ''
print 'Q9. Right handed bowlers take more wickets than left handed ones'
print m.evaluate(query,g)
x=nltk.LogicParser()
c1=x.parse('(match(x)) & rightmorethanleft(x) ')
varnames=m.satisfiers(c1,'x',g)
for i in varnames:
print i
def make_model_and_answer7(s,query):
#print s
#print query
val=nltk.parse_valuation(s)
dom=val.domain
m=nltk.Model(dom,val)
g=nltk.Assignment(dom,[])
print ''
print 'Q7. Player, who has given more than 8 runs per over and not taken a single wicket in a match for any match'
print m.evaluate(query,g)
x=nltk.LogicParser()
c1=x.parse('(player(y)) & (exists x.((match(x)) & economy8(x,y) & nowickets(x,y)))')
varnames=m.satisfiers(c1,'y',g)
for i in varnames:
print i
def make_model_and_answer15(s,query):
#print s
#print query
val=nltk.parse_valuation(s)
dom=val.domain
m=nltk.Model(dom,val)
g=nltk.Assignment(dom,[])
#print m
print ''
print 'Q15. Did Sir Jadeja bowl better in innings 1 or 2'
#print m.evaluate(query,g)
x=nltk.LogicParser()
c1=x.parse('(higher(x))')
varnames=m.satisfiers(c1,'x',g)
for i in varnames:
print i
def make_model_and_answer14(s,query):
#print s
#print query
val=nltk.parse_valuation(s)
dom=val.domain
m=nltk.Model(dom,val)
g=nltk.Assignment(dom,[])
#print m
print ''
print 'Q14. There is a player, who has been awarded player of match twice'
print m.evaluate(query,g)
x=nltk.LogicParser()
c1=x.parse('(pom(x)) & (twice(x))')
varnames=m.satisfiers(c1,'x',g)
for i in varnames:
print i
def make_model_and_answer17(s,query):
#print s
#print query
val=nltk.parse_valuation(s)
dom=val.domain
m=nltk.Model(dom,val)
g=nltk.Assignment(dom,[])
#print m
print ''
print 'Q17. Who is the better bowler, I Sharma or RA Jadeja?'
#print m.evaluate(query,g)
x=nltk.LogicParser()
c1=x.parse('(player(x)) & (better(x))')
varnames=m.satisfiers(c1,'x',g)
for i in varnames:
print i
def make_model_and_answer16(s,query):
#print s
#print query
val=nltk.parse_valuation(s)
dom=val.domain
m=nltk.Model(dom,val)
g=nltk.Assignment(dom,[])
#print m
print ''
print 'Q16. Is Dhoni a hard-hitting batsman?'
print m.evaluate(query,g)
x=nltk.LogicParser()
c1=x.parse('(higher(x)) & (ans(x))')
varnames=m.satisfiers(c1,'x',g)
for i in varnames:
print i
def make_model_and_answer18(s,query):
#print s
#print query
val=nltk.parse_valuation(s)
dom=val.domain
m=nltk.Model(dom,val)
g=nltk.Assignment(dom,[])
#print m
print ''
print 'Q18. Who performs better, opening batsmen or middle order batsmen?'
#print m.evaluate(query,g)
x=nltk.LogicParser()
c1=x.parse('(set(x)) & (ans(x))')
varnames=m.satisfiers(c1,'x',g)
for i in varnames:
print i
def make_model_and_answer19(s,query):
#print s
#print query
val=nltk.parse_valuation(s)
dom=val.domain
m=nltk.Model(dom,val)
g=nltk.Assignment(dom,[])
#print m
print ''
print 'Q19. Do all teams that win the toss win the match?'
print m.evaluate(query,g)
x=nltk.LogicParser()
c1=x.parse('(match(y)) & (all x.((team(x)) & ((toss(y,x)) -> (win(y,x)))))')
varnames=m.satisfiers(c1,'y',g)
for i in varnames:
print i
def make_model_and_answer20(s,query):
#print s
#print query
val=nltk.parse_valuation(s)
dom=val.domain
m=nltk.Model(dom,val)
g=nltk.Assignment(dom,[])
#print m
print ''
print 'Q20. Which team will win the next match?'
#print m.evaluate(query,g)
x=nltk.LogicParser()
c1=x.parse('(team(x)) & (ans(x))')
varnames=m.satisfiers(c1,'x',g)
for i in varnames:
print i
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 test_valuationFirst(self):
# arrange
v = """
bertie => b
olive => o
cyril => c
boy => {b}
girl => {o}
dog => {c}
walk => {o, c}
see => {(b, o), (c, b), (o, c)}
"""
# act
val = nltk.parse_valuation(v)
# assert
self.assertTrue(("b", "o") in val["see"])
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 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 "************************"
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 "**************************"
# grammer and logic
# <codecell>
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)
g = nltk.Assignment(val.domain)
m = nltk.Model(val.domain, val)
sent = 'Cyril sees every boy'
grammar_file = 'grammars/book_grammars/simple-sem.fcfg'
results = nltk.batch_evaluate([sent], grammar_file, m, g)[0]
for (syntree, semrep, value) in results:
print semrep
print value
# <codecell>
sent = 'Cyril sees a boy'
results = nltk.batch_evaluate([sent], grammar_file, m, g)[0]
for (syntree, semrep, value) in results:
print semrep