def demo(): print('='*20 + 'TEST PARSE' + '='*20) dexpr = DrtExpression.fromstring print(dexpr(r'([x,y],[sees(x,y)])')) print(dexpr(r'([x],[man(x), walks(x)])')) print(dexpr(r'\x.\y.([],[sees(x,y)])')) print(dexpr(r'\x.([],[walks(x)])(john)')) print(dexpr(r'(([x],[walks(x)]) + ([y],[runs(y)]))')) print(dexpr(r'(([],[walks(x)]) -> ([],[runs(x)]))')) print(dexpr(r'([x],[PRO(x), sees(John,x)])')) print(dexpr(r'([x],[man(x), -([],[walks(x)])])')) print(dexpr(r'([],[(([x],[man(x)]) -> ([],[walks(x)]))])')) print('='*20 + 'Test fol()' + '='*20) print(dexpr(r'([x,y],[sees(x,y)])').fol()) print('='*20 + 'Test alpha conversion and lambda expression equality' + '='*20) e1 = dexpr(r'\x.([],[P(x)])') print(e1) e2 = e1.alpha_convert(Variable('z')) print(e2) print(e1 == e2) print('='*20 + 'Test resolve_anaphora()' + '='*20) print(resolve_anaphora(dexpr(r'([x,y,z],[dog(x), cat(y), walks(z), PRO(z)])'))) print(resolve_anaphora(dexpr(r'([],[(([x],[dog(x)]) -> ([y],[walks(y), PRO(y)]))])'))) print(resolve_anaphora(dexpr(r'(([x,y],[]) + ([],[PRO(x)]))'))) print('='*20 + 'Test pprint()' + '='*20) dexpr(r"([],[])").pprint() dexpr(r"([],[([x],[big(x), dog(x)]) -> ([],[bark(x)]) -([x],[walk(x)])])").pprint() dexpr(r"([x,y],[x=y]) + ([z],[dog(z), walk(z)])").pprint() dexpr(r"([],[([x],[]) | ([y],[]) | ([z],[dog(z), walk(z)])])").pprint() dexpr(r"\P.\Q.(([x],[]) + P(x) + Q(x))(\x.([],[dog(x)]))").pprint()
def _exampleList_store_selection(self, index): self._curExample = index example = self._examples[index] self._exampleList.selection_clear(0, 'end') if example: cache = self._readingCache[index] if cache: if isinstance(cache, list): self._readings = cache self._error = None else: self._readings = [] self._error = cache else: try: self._readings = self._glue.parse_to_meaning(example) self._error = None self._readingCache[index] = self._readings except Exception as e: self._readings = [] self._error = DrtVariableExpression(Variable('Error: ' + str(e))) self._readingCache[index] = self._error #add a star to the end of the example self._exampleList.delete(index) self._exampleList.insert(index, (' %s *' % example)) self._exampleList.config(height=min(len(self._examples), 25), width=40) self._populate_readingListbox() self._exampleList.selection_set(index) self._drs = None self._redraw()
def applyto(self, arg): """self = (\\x.(walk x), (subj -o f)) arg = (john , subj) returns ((walk john), f) """ if self.indices & arg.indices: # if the sets are NOT disjoint raise linearlogic.LinearLogicApplicationException( f"'{self}' applied to '{arg}'. Indices are not disjoint." ) else: # if the sets ARE disjoint return_indices = self.indices | arg.indices try: return_glue = linearlogic.ApplicationExpression( self.glue, arg.glue, arg.indices ) except linearlogic.LinearLogicApplicationException as e: raise linearlogic.LinearLogicApplicationException( f"'{self.simplify()}' applied to '{arg.simplify()}'" ) from e arg_meaning_abstracted = arg.meaning if return_indices: for dep in self.glue.simplify().antecedent.dependencies[ ::-1 ]: # if self.glue is (A -o B), dep is in A.dependencies arg_meaning_abstracted = self.make_LambdaExpression( Variable("v%s" % dep), arg_meaning_abstracted ) return_meaning = self.meaning.applyto(arg_meaning_abstracted) return self.__class__(return_meaning, return_glue, return_indices)
def combine_signatures_or_rename_preds(signatures, exprs, preferred_sig=None): """ `signatures` is a list of dictionaries. Each dictionary has key-value pairs where key is a predicate name, and value is a type object. `exprs` are logical formula objects. This function return a single signature dictionary with merged signatures. If there is a predicate for which there are differing types, then the predicate is renamed and each version is associated to a different type in the signature dictionary. The target predicate is also renamed in the logical expressions. """ assert len(signatures) == len(exprs) signatures_merged = {} exprs_new = [] for i, (signature, expr) in enumerate(zip(signatures, exprs)): expr_new = expr for pred, typ in signature.items(): if preferred_sig is not None and pred in preferred_sig: continue if pred not in signatures_merged: signatures_merged[pred] = typ else: if typ != signatures_merged[pred]: pred_new = pred + '_' + str(i) signatures_merged[pred_new] = typ expr_new = expr_new.replace(Variable(pred), lexpr(pred_new)) exprs_new.append(expr_new) return signatures_merged, exprs_new
def make_VariableExpression(self, name): if ":" in name: prefix = name.split(":")[0] if prefix in self._constant_type_prefixes: return TypedConstantExpression(Variable(name), self._constant_type_prefixes[prefix]) else: raise RuntimeError(f"Unknown prefix: {prefix}. Did you forget to pass it to the constructor?") return super(DynamicTypeLogicParser, self).make_VariableExpression(name)
def satisfiers(self, parsed, varex, g, trace=None, nesting=0): """ Generate the entities from the model's domain that satisfy an open formula. :param parsed: an open formula :type parsed: Expression :param varex: the relevant free individual variable in ``parsed``. :type varex: VariableExpression or str :param g: a variable assignment :type g: Assignment :return: a set of the entities that satisfy ``parsed``. """ spacer = ' ' indent = spacer + (spacer * nesting) candidates = [] if isinstance(varex, string_types): var = Variable(varex) else: var = varex if var in parsed.free(): if trace: print() print((spacer * nesting) + "Open formula is '%s' with assignment %s" % (parsed, g)) for u in self.domain: new_g = g.copy() new_g.add(var.name, u) if trace and trace > 1: lowtrace = trace - 1 else: lowtrace = 0 value = self.satisfy(parsed, new_g, lowtrace) if trace: print(indent + "(trying assignment %s)" % new_g) # parsed == False under g[u/var]? if value == False: if trace: print(indent + "value of '%s' under %s is False" % (parsed, new_g)) # so g[u/var] is a satisfying assignment else: candidates.append(u) if trace: print(indent + "value of '%s' under %s is %s" % (parsed, new_g, value)) result = set(c for c in candidates) # var isn't free in parsed else: raise Undefined("%s is not free in %s" % (var.name, parsed)) return result
def interpret(self, ex): """ :param ex: ``AbstractBoxerDrs`` :return: ``AbstractDrs`` """ if isinstance(ex, BoxerDrs): drs = DRS([Variable('x%d' % r) for r in ex.refs], map(self.interpret, ex.conds)) if ex.label is not None: drs.label = Variable('x%d' % ex.label) if ex.consequent is not None: drs.consequent = self.interpret(ex.consequent) return drs elif isinstance(ex, BoxerNot): return DrtNegatedExpression(self.interpret(ex.drs)) elif isinstance(ex, BoxerPred): pred = self._add_occur_indexing('%s_%s' % (ex.pos, ex.name), ex) return self._make_atom(pred, 'x%d' % ex.var) elif isinstance(ex, BoxerNamed): pred = self._add_occur_indexing('ne_%s_%s' % (ex.type, ex.name), ex) return self._make_atom(pred, 'x%d' % ex.var) elif isinstance(ex, BoxerRel): pred = self._add_occur_indexing('%s' % (ex.rel), ex) return self._make_atom(pred, 'x%d' % ex.var1, 'x%d' % ex.var2) elif isinstance(ex, BoxerProp): return DrtProposition(Variable('x%d' % ex.var), self.interpret(ex.drs)) elif isinstance(ex, BoxerEq): return DrtEqualityExpression( DrtVariableExpression(Variable('x%d' % ex.var1)), DrtVariableExpression(Variable('x%d' % ex.var2))) elif isinstance(ex, BoxerCard): pred = self._add_occur_indexing('card_%s_%s' % (ex.type, ex.value), ex) return self._make_atom(pred, 'x%d' % ex.var) elif isinstance(ex, BoxerOr): return DrtOrExpression(self.interpret(ex.drs1), self.interpret(ex.drs2)) elif isinstance(ex, BoxerWhq): drs1 = self.interpret(ex.drs1) drs2 = self.interpret(ex.drs2) return DRS(drs1.refs + drs2.refs, drs1.conds + drs2.conds) assert False, '%s: %s' % (ex.__class__.__name__, ex)
def rename_guided(expr, resolution_guide): """ resolution_guide is a dictionary whose keys are expressions and values are tuples (previous_pred, new_pred) that guide the renaming. """ replacements = resolution_guide.get(expr, []) for prev_pred, new_pred in replacements: expr = expr.replace(Variable(prev_pred), lexpr(new_pred)) return expr
def get_rc_rules(rc, mainrole, mainnum, rc_index, bindings, inflections): s = '' rtype = rc['rtype'] relrole = rc['role'] relevent = rc['event'].name reltense = rc['event'].tense relpol = rc['event'].pol relpolx = rc['event'].polx relaspect = rc['event'].aspect if relrole == 'patient': if 'agent' in rc['event'].participants: ag = rc['event'].participants['agent'] nps, rc_index, bindings = get_np_rules('%srelagent' % mainrole, ag, rc_index, bindings, inflections) s += nps if rtype == 'src': s += "RC[ROLE='%s']-> T VP[VOICE='passive',ASPECT = '%s',NUM=?nrc%s,HEAD='%s',POL='%s'] NP[ROLE='%srelagent']\n"\ %(mainrole,relaspect,rc_index,relevent,relpol,mainrole) rcnum = mainnum elif rtype == 'orc': s += "RC[ROLE='%s']-> T NP[ROLE='%srelagent'] VP[VOICE='active',ASPECT = '%s',NUM=?nrc%s,HEAD='%s',POL='%s']\n"\ %(mainrole,mainrole,relaspect,rc_index,relevent,relpol) rcnum = ag.num elif relrole == 'agent': if 'patient' in rc['event'].participants: pa = rc['event'].participants['patient'] nps, rc_index, bindings = get_np_rules('%srelpatient' % mainrole, pa, rc_index, bindings, inflections) s += nps if rtype == 'src': s += "RC[ROLE='%s']-> T VP[VOICE='active',ASPECT = '%s',NUM=?nrc%s,HEAD='%s',POL='%s'] NP[ROLE='%srelpatient']\n"\ %(mainrole,relaspect,rc_index,relevent,relpol,mainrole) rcnum = mainnum elif rtype == 'orc': s += "RC[ROLE='%s']->T NP[ROLE='%srelpatient'] VP[VOICE='passive',ASPECT='%s',NUM=?nrc%s,HEAD='%s',POL='%s'] \n"\ %(mainrole,mainrole,relaspect,rc_index,relevent,relpol) rcnum = pa.num elif rc['event'].frame == 'intransitive': s += "RC[ROLE='%s']-> T VP[VOICE='active',ASPECT = '%s',NUM=?nrc%s,HEAD='%s',POL='%s']\n"\ %(mainrole,relaspect,rc_index,relevent,relpol) rcnum = mainnum vps = get_vp_rules(relevent, reltense, relpol, relpolx, rel_index=rc_index) s += vps vrs = get_verb_rules(relevent, inflections) s += vrs bindings[Variable('?nrc%s' % rc_index)] = rcnum rc_index += 1 return s, rc_index, bindings
def find_answers(self, verbose=False): self.prove(verbose) answers = set() answer_ex = VariableExpression(Variable(ResolutionProver.ANSWER_KEY)) for clause in self._clauses: for term in clause: if isinstance(term, ApplicationExpression) and\ term.function == answer_ex and\ not isinstance(term.argument, IndividualVariableExpression): answers.add(term.argument) return answers
def test_valid_lambda_expr(): """ Regression test: valid_lambda_expr was rejecting this good sub-expression at c720b4 """ ontology = _make_mock_ontology() eq_( ontology._valid_lambda_expr( Expression.fromstring(r"\b.ltzero(cmp_pos(ax_x,a,b))"), ctx_bound_vars=()), False) eq_( ontology._valid_lambda_expr( Expression.fromstring(r"\b.ltzero(cmp_pos(ax_x,a,b))"), ctx_bound_vars=(Variable('a'), )), True)
def _attempt_proof_app(self, current, context, agenda, accessible_vars, atoms, debug): f, args = current.uncurry() for i, arg in enumerate(args): if not TableauProver.is_atom(arg): ctx = f nv = Variable('X%s' % _counter.get()) for j,a in enumerate(args): ctx = (ctx(VariableExpression(nv)) if i == j else ctx(a)) if context: ctx = context(ctx).simplify() ctx = LambdaExpression(nv, ctx) agenda.put(arg, ctx) return self._attempt_proof(agenda, accessible_vars, atoms, debug+1) raise Exception('If this method is called, there must be a non-atomic argument')
def replace_function_names(expr, resolution_guide, active=None): if active is None: active = {} else: active = dict(active) if expr in resolution_guide: for prev_pred, new_pred in resolution_guide[expr]: active[prev_pred] = new_pred if isinstance(expr, ConstantExpression) or \ isinstance(expr, AbstractVariableExpression) or \ isinstance(expr, Variable): return expr elif isinstance(expr, NegatedExpression): expr.term = replace_function_names(expr.term, resolution_guide, active) return expr elif isinstance(expr, BinaryExpression): child_exprs = [expr.first, expr.second] exprs = [ replace_function_names(e, resolution_guide, active) for e in child_exprs ] expr.first = exprs[0] expr.second = exprs[1] elif isinstance(expr, ApplicationExpression): func, args = expr.uncurry() if str(func) in active: func = type(func)(Variable(active[str(func)])) args_exprs = [ replace_function_names(e, resolution_guide, active) for e in args ] exprs = [func] + args_exprs expr = functools.reduce(lambda f, a: ApplicationExpression(f, a), exprs) elif isinstance(expr, VariableBinderExpression): child_exprs = [expr.variable, expr.term] exprs = [ replace_function_names(e, resolution_guide, active) for e in child_exprs ] expr.variable = exprs[0] expr.term = exprs[1] else: raise NotImplementedError( 'Expression not recognized: {0}, type: {1}'.format( expr, type(expr))) return expr
def demo(): print '=' * 20 + 'TEST PARSE' + '=' * 20 parser = DrtParser() print parser.parse(r'([x,y],[sees(x,y)])') print parser.parse(r'([x],[man(x), walks(x)])') print parser.parse(r'\x.\y.([],[sees(x,y)])') print parser.parse(r'\x.([],[walks(x)])(john)') print parser.parse(r'(([x],[walks(x)]) + ([y],[runs(y)]))') print parser.parse(r'(([],[walks(x)]) -> ([],[runs(x)]))') print parser.parse(r'([x],[PRO(x), sees(John,x)])') print parser.parse(r'([x],[man(x), -([],[walks(x)])])') print parser.parse(r'([],[(([x],[man(x)]) -> ([],[walks(x)]))])') print '=' * 20 + 'Test fol()' + '=' * 20 print parser.parse(r'([x,y],[sees(x,y)])').fol() print '=' * 20 + 'Test alpha conversion and lambda expression equality' + '=' * 20 e1 = parser.parse(r'\x.([],[P(x)])') print e1 e2 = e1.alpha_convert(Variable('z')) print e2 print e1 == e2 print '=' * 20 + 'Test resolve_anaphora()' + '=' * 20 print resolve_anaphora( parser.parse(r'([x,y,z],[dog(x), cat(y), walks(z), PRO(z)])')) print resolve_anaphora( parser.parse(r'([],[(([x],[dog(x)]) -> ([y],[walks(y), PRO(y)]))])')) print resolve_anaphora(parser.parse(r'(([x,y],[]) + ([],[PRO(x)]))')) print '=' * 20 + 'Test pprint()' + '=' * 20 parser.parse(r"([],[])").pprint() parser.parse( r"([],[([x],[big(x), dog(x)]) -> ([],[bark(x)]) -([x],[walk(x)])])" ).pprint() parser.parse(r"([x,y],[x=y]) + ([z],[dog(z), walk(z)])").pprint() parser.parse( r"([],[([x],[]) | ([y],[]) | ([z],[dog(z), walk(z)])])").pprint() parser.parse(r"\P.\Q.(([x],[]) + P(x) + Q(x))(\x.([],[dog(x)]))").pprint()
def readings(self, trail=[]): state_reference_point = None index = trail[-1].conds.index(self) #state reference point in case there are no previous events for drs in (ancestor for ancestor in ReverseIterator(trail) if isinstance(ancestor, DRS)): search_list = drs.refs if drs is trail[-1]: #Described eventuality in the object's referents? #Take refs' list up to described eventuality search_list = drs.refs[:drs.refs.index(self.argument.variable)] for ref in ReverseIterator(search_list): #search for the most recent reference refex = DrtVariableExpression(ref) if isinstance(refex, DrtEventVariableExpression) and \ not (refex == self.argument) and not self.function.variable.name == DrtTokens.PERF: if isinstance(self.argument, DrtEventVariableExpression): #In case given eventuality is an event, return earlier return [ Binding([ (trail[-1], ConditionReplacer(index, [ self._combine(DrtTokens.EARLIER, refex, self.argument) ])) ]) ], False elif isinstance(self.argument, DrtStateVariableExpression): #In case given eventuality is a state, return include return [ Binding([ (trail[-1], ConditionReplacer(index, [ self._combine(DrtTokens.INCLUDE, self.argument, refex) ])) ]) ], False elif not state_reference_point and \ isinstance(refex, DrtStateVariableExpression) and \ not (refex == self.argument): #In case no event is found, locate the most recent state state_reference_point = refex if state_reference_point: if self.function.variable.name == DrtTokens.PERF: #in case we are dealing with PERF if isinstance(self.argument, DrtEventVariableExpression): #Reference point is a state and described eventuality an event, #return event abuts on state return [ Binding([ (trail[-1], ConditionReplacer(index, [ self._combine(DrtTokens.ABUT, self.argument, state_reference_point) ])) ]) ], False elif isinstance(self.argument, DrtStateVariableExpression): #Reference point is a state and described eventuality a state, #then add an event referent to the ancestor's refs list and two conditions #that that event is the end of eventuality and #that event abuts on ref.state. Function object needed. termination_point = unique_variable(Variable("e")) conds = [ DrtEqualityExpression( DrtEventVariableExpression(termination_point), DrtApplicationExpression( self.make_ConstantExpression(DrtTokens.END), self.argument)), self._combine( DrtTokens.ABUT, DrtEventVariableExpression(termination_point), state_reference_point) ] return [ Binding([ (trail[-1], DrtFindEventualityExpression.ConditionReplacer( index, conds, termination_point)) ]) ], False elif isinstance(self.argument, DrtStateVariableExpression): #Reference point is a state and given eventuality is also a state, #return overlap return [ Binding([(trail[-1], ConditionReplacer(index, [ self._combine(DrtTokens.OVERLAP, state_reference_point, self.argument) ]))]) ], False elif isinstance(self.argument, DrtEventVariableExpression): #Reference point is a state and given eventuality is an event, #return include return [ Binding([(trail[-1], ConditionReplacer(index, [ self._combine(DrtTokens.INCLUDE, state_reference_point, self.argument) ]))]) ], False else: #no suitable reference found return [Binding([(trail[-1], ConditionRemover(index))])], False
def make_VariableExpression(self, name): return DrtVariableExpression(Variable(name))
def mainLogic(doc): departFlag = False departVpFlag = False arriveFlag = False sourceVpFlag = False destVpFlag = False busNameNpFlag = False destNpFlag = False d = '' t = '' a = '' time = '' nameDepart = '' nameArrive = '' bVar = '' h_BusName = '' busName = '' timeDepart = '' cityTokenText = ['Hồ_Chí_Minh', 'Hà_Nội', 'Huế', 'Đà_nẵng', 'Đà_Nẵng'] busTokenText = ['B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7', 'B8'] cityTokenDep = ['compound', 'nmod', 'obl'] (f, typeWh) = ('f2', 'WHICH1') if ( subtree_matcher(doc, 'det', text='nào') != []) else ('h1', 'HOWLONG1') if (typeWh == 'WHICH1'): gap = f else: #Runtime (HOWLONG1 case) gap = 'r2' if (gap == 'f2'): if subtree_matcher(doc, 'case', text='đến') != [] or subtree_matcher( doc, 'ccomp', text='đến') != []: arriveFlag = True a = 'a3' # time=subtree_matcher(doc,'nummod')[0] if (len(subtree_matcher(doc,'nummod'))==1) else subtree_matcher(doc,'nummod') # print([i.text for i in searchChild(doc,'ROOT')]) try: time = [ i.text for i in searchChild(doc, 'ROOT') if 'HR' in i.text ][0] except: time = '' if time != '': t = 't2' else: t = '?t' ################################################ if subtree_matcher(doc, 'ROOT', text='đi') != []: departFlag = True d = 'd3' for cT in cityTokenText: for cD in cityTokenDep: temp = subtree_matcher(doc, cD, cT) tempHead = checkHead(doc, temp) try: tempChild = [i.text for i in searchChild(doc, cD)] except: tempChild = '' if (temp != []) and (tempHead != 'đi'): destVpFlag = True nameArrive = temp elif (temp != []) and (tempHead == 'đi') and ('từ' in tempChild): sourceVpFlag = True nameDepart = temp elif (temp != []) and (tempHead == 'đi') and ('đến' in tempChild): destVpFlag = True nameArrive = temp # elif subtree_matcher(doc,'ROOT',text='xuất_phát')!=[]: # departFlag=True # d='d3' # for cT in cityTokenText: # for cD in cityTokenDep: # temp=subtree_matcher(doc,cD,cT) # tempHead=checkHead(doc,temp) # # try: # # tempChild=[i.text for i in searchChild(doc,cD)] # # except: # # tempChild='' # if (temp !=[]) and (tempHead!='xuất_phát'): # destVpFlag=True # nameDepart= temp # # elif (temp !=[]) and (tempHead=='xuất_phát') and ('từ' in tempChild): # # sourceVpFlag=True # # nameDepart= temp # # elif (temp !=[]) and (tempHead=='xuất_phát') and ('đến' in tempChild): # # destVpFlag=True # # nameArrive= temp else: for cT in cityTokenText: for cD in cityTokenDep: temp = subtree_matcher(doc, cD, cT) if temp != []: destNpFlag = True nameArrive = temp break else: # Continue if the inner loop wasn't broken. continue # Inner loop was broken, break the outer. break elif subtree_matcher(doc, 'ROOT', text='xuất_phát') != []: departFlag = True d = 'd3' for cT in cityTokenText: for cD in cityTokenDep: temp = subtree_matcher(doc, cD, cT) tempHead = checkHead(doc, temp) # try: # tempChild=[i.text for i in searchChild(doc,cD)] # except: # tempChild='' if (temp != []) and (tempHead != 'xuất_phát'): departVpFlag = True nameDepart = temp # elif (temp !=[]) and (tempHead=='xuất_phát') and ('từ' in tempChild): # sourceVpFlag=True # nameDepart= temp # elif (temp !=[]) and (tempHead=='xuất_phát') and ('đến' in tempChild): # destVpFlag=True # nameArrive= temp # print(destNpFlag) # Variable('?hDest'),name=Variable('?nameDest') elif (gap == 'r2'): if (subtree_matcher(doc, 'ROOT', text='đến')) != []: arriveFlag = True a = 'a3' time = '?time' t = '?t' nameArrive = subtree_matcher(doc, 'obj')[0] if (len( subtree_matcher(doc, 'obj')) == 1) else subtree_matcher( doc, 'obj') if type(nameArrive) == list: for obj in nameArrive: if obj in cityTokenText: nameArrive = obj break if nameArrive != '': h = 'h4' destVpFlag = True else: h = '?h' if subtree_matcher(doc, 'case', text='từ') != []: d = 'd3' nameDepart = checkHead(doc, 'từ') if (nameDepart != ''): sourceVpFlag listObj = subtree_matcher(doc, 'obj') listCompound = subtree_matcher(doc, 'compound') for sub in listObj: if sub in busTokenText: busName = sub if busName == '': for sub in listCompound: if sub in busTokenText: busName = sub if busName != '': busNameNpFlag = True bVar = 'f2' h_BusName = 'h3' if arriveFlag and not (destVpFlag) and not (sourceVpFlag): vp = FeatStruct( arrive=FeatStruct(a=a, f=f, t=FeatStruct(t_var=t, time_var=time))) elif departFlag and departVpFlag: vp = FeatStruct( depart=FeatStruct(d='d3', f='f1', t=FeatStruct(t_var=t, time_var=time)), source=FeatStruct(bus='h3', sourceName=FeatStruct(f=Variable('?h'), name=nameDepart))) else: vp = FeatStruct( depart=FeatStruct(d='d3', f='f1', t=FeatStruct(t_var=t, time_var=time)), source=FeatStruct(bus='h4', sourceName=FeatStruct(f=Variable('?h'), name=nameDepart)), arrive=FeatStruct(a='a3', f='f2', t=FeatStruct(t_var=t, time_var=time)), dest=FeatStruct(destName=FeatStruct( f=Variable('?f'), name=FeatStruct(h='h6', name=nameArrive)))) if destNpFlag and not (busNameNpFlag): np = FeatStruct(dest=FeatStruct( bus=Variable('?f'), dest=FeatStruct(f=Variable('?f'), name=FeatStruct(h='h3', name=nameArrive)))) else: np = FeatStruct(the=FeatStruct( bus=bVar, busname=FeatStruct(h=h_BusName, name=busName))) wh = FeatStruct(whType=FeatStruct(f=f, type=typeWh)) sem = FeatStruct(query=FeatStruct(vp=vp, np=np, wh=wh)) var = Variable('?a') result = featStruct(gap, sem, var, arriveFlag=arriveFlag, destVpFlag=destVpFlag, sourceVpFlag=sourceVpFlag, busNameNpFlag=busNameNpFlag, destNpFlag=destNpFlag, departFlag=departFlag, departVpFlag=departVpFlag) print(result) return result
def featStruct(gapUp, semUp, varUp, arriveFlag=False, destVpFlag=False, sourceVpFlag=False, busNameNpFlag=False, destNpFlag=False, departFlag=False, departVpFlag=False): gap = Variable('?gap') if arriveFlag and not (destVpFlag) and not (sourceVpFlag): vp = FeatStruct(arrive=FeatStruct( a=Variable('?a'), f=Variable('?f'), t=FeatStruct(t_var=Variable('?t'), time_var=Variable('?time')))) elif departFlag and departVpFlag: vp = FeatStruct(depart=FeatStruct( d=Variable('?d'), f=Variable('?fDep'), t=FeatStruct(t_var=Variable('?t_var_dep'), time_var=Variable('?timeDepart'))), source=FeatStruct(bus=Variable('?h'), sourceName=FeatStruct( f=Variable('?h'), name=Variable('?nameSource')))) else: vp = FeatStruct( depart=FeatStruct(d=Variable('?d'), f=Variable('?fDep'), t=FeatStruct(t_var=Variable('?t_var_dep'), time_var=Variable('?timeDepart'))), source=FeatStruct(bus=Variable('?h'), sourceName=FeatStruct( f=Variable('?h'), name=Variable('?nameSource'))), arrive=FeatStruct(a=Variable('?a'), f=Variable('?fArr'), t=FeatStruct(t_var=Variable('?t_var_arr'), time_var=Variable('?timeArrive'))), dest=FeatStruct(destName=FeatStruct( f=Variable('?f'), name=FeatStruct(h=Variable('?hDest'), name=Variable('?nameDest'))))) if destNpFlag and not (busNameNpFlag): np = FeatStruct(dest=FeatStruct( bus=Variable('?f'), dest=FeatStruct(f=Variable('?f'), name=FeatStruct(h=Variable('?h'), name=Variable('?name'))))) else: np = FeatStruct( the=FeatStruct(bus=Variable('?b'), busname=FeatStruct(h=Variable('?h_BusName'), name=Variable('?busName')))) wh = FeatStruct( whType=FeatStruct(f=Variable('?f'), type=Variable('?type'))) sem = FeatStruct(query=FeatStruct(vp=vp, np=np, wh=wh)) var = Variable('?a') para = FeatStruct(gap=gap, sem=sem, var=var) paraUpdate = FeatStruct(gap=gapUp, sem=semUp, var=varUp) # print('$$$$$$$$$$$$$$$$$$$$$$$$$$$$$') # print(paraUpdate) # paraUpdate.unify(para)['sem']['query']['vp']['arrive']['f'] return paraUpdate.unify(para)
def _attempt_proof_n_app(self, current, context, agenda, accessible_vars, atoms, debug): f, args = current.term.uncurry() for i, arg in enumerate(args): if not TableauProver.is_atom(arg): ctx = f nv = Variable('X%s' % _counter.get()) for j,a in enumerate(args): if i==j: ctx = (ctx(VariableExpression(nv)) if i == j else ctx(a)) if context: #combine new context with existing ctx = context(ctx).simplify() ctx = LambdaExpression(nv, -ctx) agenda.put(-arg, ctx) return self._attempt_proof(agenda, accessible_vars, atoms, debug+1) raise Exception('If this method is called, there must be a non-atomic argument') def _attempt_proof_n_eq(self, current, context, agenda, accessible_vars, atoms, debug): ########################################################################### # Since 'current' is of type '~(a=b)', the path is closed if 'a' == 'b' ########################################################################### if current.term.first == current.term.second: debug.line('CLOSED', 1) return True agenda[Categories.N_EQ].add((current,context)) current._exhausted = True return self._attempt_proof(agenda, accessible_vars|set([current.term.first, current.term.second]), atoms, debug+1) def _attempt_proof_d_neg(self, current, context, agenda, accessible_vars, atoms, debug): agenda.put(current.term.term, context) return self._attempt_proof(agenda, accessible_vars, atoms, debug+1) def _attempt_proof_n_all(self, current, context, agenda, accessible_vars, atoms, debug): agenda[Categories.EXISTS].add((ExistsExpression(current.term.variable, -current.term.term), context)) return self._attempt_proof(agenda, accessible_vars, atoms, debug+1) def _attempt_proof_n_some(self, current, context, agenda, accessible_vars, atoms, debug): agenda[Categories.ALL].add((AllExpression(current.term.variable, -current.term.term), context)) return self._attempt_proof(agenda, accessible_vars, atoms, debug+1) def _attempt_proof_and(self, current, context, agenda, accessible_vars, atoms, debug): agenda.put(current.first, context) agenda.put(current.second, context) return self._attempt_proof(agenda, accessible_vars, atoms, debug+1) def _attempt_proof_n_or(self, current, context, agenda, accessible_vars, atoms, debug): agenda.put(-current.term.first, context) agenda.put(-current.term.second, context) return self._attempt_proof(agenda, accessible_vars, atoms, debug+1) def _attempt_proof_n_imp(self, current, context, agenda, accessible_vars, atoms, debug): agenda.put(current.term.first, context) agenda.put(-current.term.second, context) return self._attempt_proof(agenda, accessible_vars, atoms, debug+1) def _attempt_proof_or(self, current, context, agenda, accessible_vars, atoms, debug): new_agenda = agenda.clone() agenda.put(current.first, context) new_agenda.put(current.second, context) return self._attempt_proof(agenda, accessible_vars, atoms, debug+1) and \ self._attempt_proof(new_agenda, accessible_vars, atoms, debug+1) def _attempt_proof_imp(self, current, context, agenda, accessible_vars, atoms, debug): new_agenda = agenda.clone() agenda.put(-current.first, context) new_agenda.put(current.second, context) return self._attempt_proof(agenda, accessible_vars, atoms, debug+1) and \ self._attempt_proof(new_agenda, accessible_vars, atoms, debug+1) def _attempt_proof_n_and(self, current, context, agenda, accessible_vars, atoms, debug): new_agenda = agenda.clone() agenda.put(-current.term.first, context) new_agenda.put(-current.term.second, context) return self._attempt_proof(agenda, accessible_vars, atoms, debug+1) and \ self._attempt_proof(new_agenda, accessible_vars, atoms, debug+1) def _attempt_proof_iff(self, current, context, agenda, accessible_vars, atoms, debug): new_agenda = agenda.clone() agenda.put(current.first, context) agenda.put(current.second, context) new_agenda.put(-current.first, context) new_agenda.put(-current.second, context) return self._attempt_proof(agenda, accessible_vars, atoms, debug+1) and \ self._attempt_proof(new_agenda, accessible_vars, atoms, debug+1) def _attempt_proof_n_iff(self, current, context, agenda, accessible_vars, atoms, debug): new_agenda = agenda.clone() agenda.put(current.term.first, context) agenda.put(-current.term.second, context) new_agenda.put(-current.term.first, context) new_agenda.put(current.term.second, context) return self._attempt_proof(agenda, accessible_vars, atoms, debug+1) and \ self._attempt_proof(new_agenda, accessible_vars, atoms, debug+1) def _attempt_proof_eq(self, current, context, agenda, accessible_vars, atoms, debug): ######################################################################### # Since 'current' is of the form '(a = b)', replace ALL free instances # of 'a' with 'b' ######################################################################### agenda.put_atoms(atoms) agenda.replace_all(current.first, current.second) accessible_vars.discard(current.first) agenda.mark_neqs_fresh(); return self._attempt_proof(agenda, accessible_vars, set(), debug+1) def _attempt_proof_some(self, current, context, agenda, accessible_vars, atoms, debug): new_unique_variable = VariableExpression(unique_variable()) agenda.put(current.term.replace(current.variable, new_unique_variable), context) agenda.mark_alls_fresh() return self._attempt_proof(agenda, accessible_vars|set([new_unique_variable]), atoms, debug+1) def _attempt_proof_all(self, current, context, agenda, accessible_vars, atoms, debug): try: current._used_vars except AttributeError: current._used_vars = set() #if there are accessible_vars on the path if accessible_vars: # get the set of bound variables that have not be used by this AllExpression bv_available = accessible_vars - current._used_vars if bv_available: variable_to_use = list(bv_available)[0] debug.line('--> Using \'%s\'' % variable_to_use, 2) current._used_vars |= set([variable_to_use]) agenda.put(current.term.replace(current.variable, variable_to_use), context) agenda[Categories.ALL].add((current,context)) return self._attempt_proof(agenda, accessible_vars, atoms, debug+1) else: #no more available variables to substitute debug.line('--> Variables Exhausted', 2) current._exhausted = True agenda[Categories.ALL].add((current,context)) return self._attempt_proof(agenda, accessible_vars, atoms, debug+1) else: new_unique_variable = VariableExpression(unique_variable()) debug.line('--> Using \'%s\'' % new_unique_variable, 2) current._used_vars |= set([new_unique_variable]) agenda.put(current.term.replace(current.variable, new_unique_variable), context) agenda[Categories.ALL].add((current,context)) agenda.mark_alls_fresh() return self._attempt_proof(agenda, accessible_vars|set([new_unique_variable]), atoms, debug+1) @staticmethod def is_atom(e): if isinstance(e, NegatedExpression): e = e.term if isinstance(e, ApplicationExpression): for arg in e.args: if not TableauProver.is_atom(arg): return False return True elif isinstance(e, AbstractVariableExpression) or \ isinstance(e, LambdaExpression): return True else: return False
def _make_atom(self, pred, *args): accum = DrtVariableExpression(Variable(pred)) for arg in args: accum = DrtApplicationExpression( accum, DrtVariableExpression(Variable(arg))) return accum
def fill_details(event_input, nxlist, voice=None, nx=None, dv=False): event = deepcopy(event_input) if not event.tense: event.tense = choice(['past', 'pres']) if not event.aspect: event.aspect = choice(['prog', 'neut'], p=[.3, .7]) if not event.voice: if voice: event.voice = voice else: event.voice = choice(helper_dicts.voices[event.frame]) if not event.pol: event.pol = choice(['pos', 'neg'], p=[.8, .2]) # if event.pol == 'neg' and nx and not event.polx: if nx and not event.polx: num_extras = max(0, min(nx, int(round(1 * np.random.randn() + 1)))) if num_extras > 0: advlist = copy(nxlist) random.shuffle(advlist) px = ' , '.join(advlist[:num_extras]) #take the first num_extras of them and add them in order as the content for polx event.polx = px #TODO remove this line if we take care of populating frame elsewhere if not event.frame: event.frame = frames[event.name] for part in event.participants: if not event.participants[part].num: event.participants[part].num = choice(['sg', 'pl']) if not event.participants[part].det: if dv: predet = choice(['def', 'indef']) event.participants[part].det = helper_dicts.defnum2det[predet][ event.participants[part].num] else: event.participants[part].det = 'the' event.bindings[Variable('?n%s' % part)] = event.participants[part].num if 'rc' in event.participants[part].attributes: fr = event.participants[part].attributes['rc']['event'].frame if not event.participants[part].attributes['rc'][ 'rtype'] and not event.participants[part].attributes['rc'][ 'event'].voice: #for now, try to avoid ORC with hostrole as agent, since eg "the professor that the company was called by" is a bit extreme if event.participants[part].attributes['rc'][ 'role'] == 'agent': event.participants[part].attributes['rc'][ 'rtype'] = choice(['orc', 'src'], p=[.05, .95]) else: event.participants[part].attributes['rc'][ 'rtype'] = choice(['orc', 'src']) #voice in RC is deterministic from hostrole and rtype, so set that here chosen_role = event.participants[part].attributes['rc']['role'] chosen_rtype = event.participants[part].attributes['rc'][ 'rtype'] event.participants[part].attributes['rc'][ 'event'].voice = helper_dicts.rolertype2voice[chosen_role][ chosen_rtype] elif not event.participants[part].attributes['rc'][ 'rtype'] and event.participants[part].attributes['rc'][ 'event'].voice: chosen_role = event.participants[part].attributes['rc']['role'] chosen_voice = event.participants[part].attributes['rc'][ 'event'].voice event.participants[part].attributes['rc'][ 'rtype'] = helper_dicts.rolevoice2rtype[chosen_role][ chosen_voice] rcevent = fill_details( event.participants[part].attributes['rc']['event'], nxlist, nx=nx, dv=dv) event.participants[part].attributes['rc']['event'] = rcevent return event
def test_as_ec_sexpr_function(): ont = _make_mock_ontology() expr = FunctionVariableExpression(Variable("and_", ont.types["boolean", "boolean", "boolean"])) eq_(ont.as_ec_sexpr(expr), "(lambda (lambda (and_ $1 $0)))")
def make_ConstantExpression(self, name): return DrtConstantExpression(Variable(name))