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