def createRarelyRule(rule): rarelyIsRule = False rarelyIsHead = False isImplication = isinstance(rule, basicLogic.operator_bitonic_implication) rarelyIsRule = isinstance(rule, basicLogic.operator_monotonic_rarely) if isImplication: rarelyIsHead = isinstance(rule.clause2, basicLogic.operator_monotonic_rarely) rarelyInRightPlace = rarelyIsRule or rarelyIsHead if rarelyIsHead: c1 = rule.clause1 c2 = basicLogic.operator_monotonic_negation(rule.clause1) #known to be mostly c3 = basicLogic.operator_monotonic_negation(rule.clause2.clause) r = basicLogic.operator_tritonic_defaultRule(c1, c2, c3) return r elif rarelyIsRule: c1 = basicLogic.TRUE c2 = rule.clause c3 = basicLogic.operator_monotonic_negation(rule.clause) r = basicLogic.operator_tritonic_defaultRule(c1, c2, c3) return r else: print("Requirement that 'mostly' is the second clause in a->m(b)") raise Exception()
def unit_yuvalOnions(): yuval = scp.scp(epistemicStateType="dl") eatonionSoup = basicLogic.atom("eatOnionSoup") loveEating= basicLogic.atom("loveEating") eatOnions=basicLogic.atom("eatOnions") brushTeeth=basicLogic.atom("brushTeeth") careForHygiene=basicLogic.atom("careForHygiene") dontEatOnions=basicLogic.operator_monotonic_negation(eatOnions) rule1=basicLogic.operator_tritonic_defaultRule(eatonionSoup,[eatOnions],eatOnions) rule2=basicLogic.operator_tritonic_defaultRule(eatonionSoup,[loveEating],loveEating) rule3=basicLogic.operator_tritonic_defaultRule(loveEating,[brushTeeth],brushTeeth) rule4=basicLogic.operator_tritonic_defaultRule(brushTeeth,[careForHygiene],careForHygiene) rule5=basicLogic.operator_tritonic_defaultRule(careForHygiene,[dontEatOnions],dontEatOnions) factEatsOnionSoup = basicLogic.operator_bitonic_implication(basicLogic.TRUE,eatonionSoup) D = [rule1,rule2,rule3,rule4,rule5] W = [factEatsOnionSoup] V = [eatonionSoup, loveEating, eatOnions, brushTeeth, careForHygiene] yuval.addDList(D) yuval.addVList(V) yuval.addWList(W) yuval.addNext(comp_def_eval) print ("<<<<<<<<YUVAL>>>>>>>>>>") print (yuval.evaluate())
def unit_quakersRepublicans(): dick = scp.scp(epistemicStateType="dl") republican = basicLogic.atom('republican') quaker = basicLogic.atom('quaker') pacifist = basicLogic.atom('pacifist') factRepublican = basicLogic.operator_bitonic_implication(basicLogic.TRUE, republican) factQuaker = basicLogic.operator_bitonic_implication(basicLogic.TRUE, quaker) notPacifist = basicLogic.operator_monotonic_negation(pacifist) #republicans are usually not pacifists rule1 = basicLogic.operator_tritonic_defaultRule(republican,[notPacifist],notPacifist) #quakers are usually pacifists rule2 = basicLogic.operator_tritonic_defaultRule(quaker,[pacifist],pacifist) D = [rule1,rule2] W = [factRepublican,factQuaker] V = [republican,quaker,pacifist] dick.addDList(D) dick.addWList(W) dick.addVList(V) dick.addNext(comp_def_eval) print ("<<<<<<<<DICK>>>>>>>>>>") print (dick.evaluate())
def evaluateEpistemicState(self, epi): #set of conditional rules delta = epi['Delta'] S = epi['S'] V = epi['V'] resolvedDependencies = [] for conditional in delta: consequence = conditional.clause1 precondition = conditional.clause2 if consequence not in resolvedDependencies: lowestk = m_addAB.findLowestK(epi) allDependencies = m_addAB.findAllConditionalDependencyPreconditions( consequence, delta) abBody = None for dep in allDependencies: negateDep = basicLogic.operator_monotonic_negation(dep) if dep != precondition: if abBody == None: abBody = negateDep else: abBody = basicLogic.operator_bitonic_or( abBody, negateDep) if abBody == None: abBody = basicLogic.FALSE abName = 'ab_' + str(lowestk) abAtom = basicLogic.atom(abName, None) ab = basicLogic.operator_bitonic_implication(abAtom, abBody) negABAtom = basicLogic.operator_monotonic_negation(abAtom) newBody = basicLogic.operator_bitonic_and( precondition, negABAtom) newRule = basicLogic.operator_bitonic_implication( consequence, newBody) #add the abnormality and its assignment to the list of rules S.append(newRule) S.append(ab) V.append(abAtom) resolvedDependencies = resolvedDependencies + allDependencies #all conditionals have now been interpreted epi['Delta'] = [] return epi
def createBodyFromRulesThatAffectHead(self, head, body, li_abs): #if basicLogic.isGroundAtom(body): if basicLogic.isGroundAtom(body) or basicLogic.isGroundAtom(head): return basicLogic.operator_bitonic_implication(body, head), None, li_abs newAbnormality = basicLogic.atom('ab{}'.format(len(li_abs) + 1)) negAbnormality = basicLogic.operator_monotonic_negation(newAbnormality) li_abs.append(newAbnormality) newBody = basicLogic.operator_bitonic_and(body, negAbnormality) newRule = basicLogic.operator_bitonic_implication(newBody, head) return newRule, newAbnormality, li_abs
def getVariablesFromThW(thW): v = [] for x in thW: if isinstance(x[0], basicLogic.atom): v.append(copy.deepcopy(x[0])) v[-1].setValue(x[1]) elif isinstance(x[0], basicLogic.operator_monotonic_negation): v.append(copy.deepcopy(x[0].clause)) doubleNeg = basicLogic.operator_monotonic_negation( basicLogic.atom('', x[1])) v[-1].setValue(doubleNeg.evaluate()) return v
def evaluate(self): prev_epi = self.prev.evaluate() current_epi = complexOperation.createEmptyNextEpi(prev_epi) oldkb = prev_epi.getKB() oldV = prev_epi.getV() current_epi.addVariableList(oldV) current_epi.addKnowledgeList(oldkb) for rule in oldkb: if not rule.immutable: if isinstance(rule, basicLogic.atom) and not self.isGroundAtom( rule.clause2): negateClause1 = basicLogic.operator_monotonic_negation( rule.clause1) negateClause2 = basicLogic.operator_monotonic_negation( rule.clause2) contraRule = basicLogic.operator_bitonic_implication( negateClause1, negateClause2) current_epi.addKnowledge(contraRule) return current_epi
def createNewAbnormalityInstant(self, otherRulesThatAffectHead): # case: KB={D->3, T->3} without this (T -> ab) is created otherRulesThatAffectHead = self.removeGroundFromRules( otherRulesThatAffectHead) #if nothing else affects the head, assume the abnormality is false by default if otherRulesThatAffectHead == []: rule = basicLogic.FALSE return rule rule = otherRulesThatAffectHead[0] #added a negated disjunction of all the rules for other in range(1, len(otherRulesThatAffectHead)): neg = basicLogic.operator_monotonic_negation(rule) rule = basicLogic.operator_bitonic_or(rule, neg) return rule
def unit_tweetyAndChilly (): #create the two birds as individual scps tweety = scp.scp(epistemicStateType="dl") chilly = scp.scp(epistemicStateType="dl") #variables flies = basicLogic.atom('flies') bird = basicLogic.atom('bird') notflies = basicLogic.operator_monotonic_negation(flies) #the only inference rule rule1 = basicLogic.operator_tritonic_defaultRule(bird,[flies],flies) fact_bird = basicLogic.operator_bitonic_implication(basicLogic.TRUE, bird) factNotFlies = basicLogic.operator_bitonic_implication(basicLogic.TRUE, notflies) #the set of concrete rules W_tweety=[fact_bird] W_chilly=[fact_bird,factNotFlies] #in this case both tweety and chilly share the same inference rules D = [rule1] V = [flies,bird] #create wteety tweety.addDList(D) tweety.addVList(V) tweety.addWList(W_tweety) #create chilly chilly.addDList(D) chilly.addVList(V) chilly.addWList(W_chilly) #add the complex operator for evaluating default rules tweety.addNext(comp_def_eval) chilly.addNext(comp_def_eval) print ("<<<<<<<<TWEETY>>>>>>>>>>") print (tweety.evaluate()) print (chilly.evaluate())
def evaluate(self): #get the previous epistemic state epi_prev = self.prev.evaluate() #generate an empy epistemic state of the same type as the previous one epi_next = complexOperation.createEmptyNextEpi(epi_prev) #all variables in prevkb will be present in the next one (plus abnormalities) prev_v = epi_prev.getV() epi_next.addVariableList(prev_v) #the list of created abnormalities ABs = [] prev_kb = epi_prev.getKB() for rule in prev_kb: #we do this because there can be 1 or 2 heads/bodies depending on -> or <-> body = self.getBodies(rule) head = self.getHeads(rule) if rule.immutable: epi_next.addKnowledge(rule) else: for h in head: for b in body: #truth values don't need abnormalities if basicLogic.isGroundAtom(b): newRule = basicLogic.operator_bitonic_implication( b, h) epi_next.addKnowledge(newRule) else: #find every clause x, with (x->head) rulesThatAffectHead = self.getRulesThatAffectHead( h, prev_kb) #remove this body from the list of rules that affect head otherRulesThatAffectHead = self.removeRuleFromList( b, rulesThatAffectHead) #create the new abnormality newAb = basicLogic.atom( "ab{}".format(len(ABs) + 1)) ABs.append(newAb) negAb = basicLogic.operator_monotonic_negation( newAb) newBody = basicLogic.operator_bitonic_and(b, negAb) newRule = basicLogic.operator_bitonic_implication( newBody, h) epi_next.addKnowledge(newRule) #create a valuation for the new abnormality abInstHead = newAb abInstBody = self.createNewAbnormalityInstant( otherRulesThatAffectHead) abInstBodyIsGroundValue = basicLogic.isGroundAtom( abInstBody) newAbInstBody = abInstBody if abInstBodyIsGroundValue else basicLogic.operator_monotonic_negation( abInstBody) abInstRule = basicLogic.operator_bitonic_implication( newAbInstBody, abInstHead) epi_next.addKnowledge(abInstRule) #add the new abnormality to the variable list epi_next.addVariable(newAb) return epi_next
knowledge_3 = basicLogic.operator_bitonic_implication(basicLogic.TRUE, card_3) knowledge_k = basicLogic.operator_bitonic_implication(basicLogic.TRUE, card_k) knowledge_7 = basicLogic.operator_bitonic_implication(basicLogic.TRUE, card_7) # the extra fact that 7->not(3) #CHANGED pPrime = basicLogic.operator_monotonic_negation(card_3) pPrime = basicLogic.atom("D'", None) knowledge_primeRelationp = basicLogic.operator_bitonic_implication( card_7, pPrime, immutable=True) # the extra fact that K->not(D) #CHANGED qPrime = basicLogic.operator_monotonic_negation(card_k) qPrime = basicLogic.atom("3'", None) knowledge_primeRelationq = basicLogic.operator_bitonic_implication( card_d, qPrime, immutable=True) notPPrime = basicLogic.operator_monotonic_negation(pPrime, immutable=True) knowledgeNotPtoP = basicLogic.operator_bitonic_implication(notPPrime, card_d, immutable=True) #ALL POSSIBLE VARIABLES (USED IN ABDUCTION) allVariables = (card_3, card_7, card_d, card_k, pPrime, qPrime) #INITIALISE THE SET OF COMPLEX OPERATORS M # create the complex operation to add abnormalities comp_addAB = complexOperation.complexOperation_addAB() # create the complex operation to delete a named variable comp_deleteo = complexOperation.complexOperation_deleteVariable('o') # create the complex operation to fix a named variable to a specified value comp_fixab1 = complexOperation.complexOperation_fixVariable('ab1', False) # Create the complex operation to weakly complete the logic program