def satisfiers(self, model, g=None):
# First try the fast way if this is just a predicate expression
full_init_g_obj = None
if g is None:
full_init_g_obj = self._init_g
elif len(self._init_g) == 0:
full_init_g_obj = g
else:
full_init_g = []
for var in g:
full_init_g.append((var, g[var]))
for var in self._init_g:
if var not in g:
full_init_g.append((var, self._init_g[var]))
full_init_g_obj = nltk.Assignment(self._domain, full_init_g)
maybe_sats = model.satisfying_assignments_exp_app_fast(self.get_exp(), full_init_g_obj)
if maybe_sats is not None:
return maybe_sats
# Otherwise, do the slow way
variables = []
partial_g = []
var_exprs = []
for i in range(len(self._variables)):
var = self._variables[i]
if var not in self._init_g and (g is None or var not in g):
exist_str_i = ""
for j in range(i+1, len(self._variables)):
exist_str_i += "exists " + self._variables[j] + "."
if len(exist_str_i) == 0:
var_exprs.append(self.get_exp())
else:
var_exprs.append(nltk.sem.Expression.fromstring(exist_str_i + self._form))
variables.append(var)
else:
if var in self._init_g:
partial_g.append((var, self._init_g[var]))
else:
partial_g.append((var, g[var]))
if len(variables) == 0:
partial_g_obj = nltk.Assignment(self._domain, partial_g)
if model.evaluate_exp(self.get_exp(), partial_g_obj):
return [partial_g_obj]
else:
return []
return self._satisfiers_helper(model, variables, var_exprs, 0, partial_g)
def _satisfiers_helper(self, model, variables, var_exprs, var_index, partial_g):
if var_index == len(self._variables):
return [nltk.Assignment(self._domain, partial_g)]
sats = []
var = variables[var_index]
expr = var_exprs[var_index]
var_sats = model.satisfiers_exp(expr, var, nltk.Assignment(self._domain, partial_g))
for var_sat in var_sats:
partial_g_next = copy.deepcopy(partial_g)
partial_g_next.append((var, var_sat))
sats.extend(self._satisfiers_helper(model, variables, var_exprs, var_index + 1, partial_g_next))
return sats
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 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_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 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 clone(self, var_map=dict(), symmetric=False):
new_exp = self.get_exp()
new_g = []
new_variables = []
for v in self._variables:
if v in var_map:
v_new = var_map[v]
v_exp = nltk.sem.Expression.fromstring(v)
v_new_exp = nltk.sem.Expression.fromstring(v_new)
new_exp = new_exp.replace(v_exp.variable, v_new_exp, False)
if v in self._init_g:
new_g.append((v_new, self._init_g[v]))
new_variables.append(v_new)
elif v in self._init_g:
new_g.append((v, self._init_g[v]))
new_variables.append(v)
else:
new_variables.append(v)
new_form = OpenFormula(self._domain, str(new_exp), new_variables, nltk.Assignment(self._init_g.domain, new_g))
if not symmetric:
return new_form
else:
svars = sorted(new_variables)
smap = dict()
remp_map = dict()
for i in range(len(new_variables)):
smap[new_variables[i]] = svars[i] + "_p"
remp_map[svars[i] + "_p"] = svars[i]
return new_form.clone(var_map=smap).clone(var_map=remp_map)
def _make_closed_forms(self, domain, form, variables, init_g):
assgn_lists = self._make_assignments_helper(domain, variables, init_g, 0, [[]])
closed = []
for i in range(len(assgn_lists)):
g = nltk.Assignment(domain, assgn_lists[i])
closed.append(ClosedFormula(form, g))
return closed
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 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 p_2_fn(cf):
ofs = []
for var in cf.get_g():
ofs.append(
fol.OpenFormula(domain,
"P2(" + var + ")", [var],
init_g=nltk.Assignment(
domain, [(var, cf.get_g()[var])])))
return ofs
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 setUp(self):
self.dom = set(['b1', 'c1'])
self.vals = []
for z in chain.from_iterable(combinations(self.dom, r) for r in range(len(self.dom)+1)):
self.vals.append(extrasem.Valuation([('sleep', set(z))]))
for x in self.vals:
x['john'] = 'b1'
x['mary'] = 'c1'
self.inq = extrasem.InquisitiveState(self.dom, [self.vals])
self.g1 = nltk.Assignment(self.dom, [('x', 'b1'), ('y', 'c1')])
def __init__(self, domain, form, variables, init_g=None):
self._exp = None
self._domain = domain
self._form = form
self._variables = variables
if init_g is not None:
self._init_g = init_g
else:
self._init_g = nltk.Assignment(self._domain, [])
self._closed_forms = None
self._predicates = None
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 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 orthogonize(self, closed_form):
new_exp = self.get_exp()
new_g = []
for v in self._g:
if v in closed_form.get_g():
v_new = v
while v_new in closed_form.get_g():
v_new = v_new + '1'
v_exp = nltk.sem.Expression.fromstring(v)
v_new_exp = nltk.sem.Expression.fromstring(v_new)
new_exp = new_exp.replace(v_exp.variable, v_new_exp, False)
new_g.append((v_new, self._g[v]))
else:
new_g.append((v, self._g[v]))
return ClosedFormula(str(new_exp), nltk.Assignment(self._g.domain, new_g))
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 __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 orthogonize(self, open_form):
new_exp = self.get_exp()
new_g = []
new_variables = []
for v in self._variables:
if v in open_form._variables:
v_new = v
while v_new in open_form._variables:
v_new = v_new + '1'
v_exp = nltk.sem.Expression.fromstring(v)
v_new_exp = nltk.sem.Expression.fromstring(v_new)
new_exp = new_exp.replace(v_exp.variable, v_new_exp, False)
if v in self._init_g:
new_g.append((v_new, self._init_g[v]))
new_variables.append(v_new)
elif v in self._init_g:
new_g.append((v, self._init_g[v]))
new_variables.append(v)
else:
new_variables.append(v)
return OpenFormula(self._domain, str(new_exp), new_variables, nltk.Assignment(self._init_g.domain, new_g))
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 satisfying_assignments_exp_app_fast(self, exp, g):
if not isinstance(exp, nltk.sem.logic.ApplicationExpression):
return None
pred_vars = []
for arg in exp.args:
if not isinstance(arg, nltk.sem.logic.IndividualVariableExpression):
return None
else:
pred_vars.append(str(arg))
assgns = []
pred_str = str(exp.pred)
if not pred_str in self._preds:
return assgns
pred = self._preds[pred_str]
for sat in pred:
assgn = []
consistent = True
for i in range(len(sat)):
var_i = pred_vars[i]
val_i = sat[i]
if var_i in g:
if g[var_i] != val_i:
consistent = False
break
else:
assgn.append((var_i, val_i))
if consistent:
for var in g:
assgn.append((var, g[var]))
assgns.append(nltk.Assignment(self._domain, assgn))
return assgns
