def test_biconditional(self): expression = "A <=> B" parser = PLParser() root_term = parser.parse(expression) m = Model() m = m.extend("A", True).extend("B", True) self.assertTrue(m.is_true(root_term)) m.clear() m = m.extend("A", True).extend("B", False) self.assertFalse(m.is_true(root_term)) m.clear() m = m.extend("A", False).extend("B", True) self.assertFalse(m.is_true(root_term)) m.clear() m = m.extend("A", False).extend("B", False) self.assertTrue(m.is_true(root_term)) m.clear()
def _test_pl_resolve(self, expr1, expr2, expected_symbol): sentence1 = PLParser().parse(expr1) sentence2 = PLParser().parse(expr2) pl_resolution = PLResolution() symbol = pl_resolution._pl_resolve(sentence1, sentence2) self.assertEquals(expected_symbol, symbol)
def test_collect_symbols(self): expression = "(A AND NOT B) => B <=> NOT C OR D => E" parser = PLParser() root_term = parser.parse(expression) sc = SymbolsCollector() sc.collect_symbols(root_term) result_symbols = sc.symbols expected_symbols = ["A", "B", "C", "D", "E"] self.assertSameElements(expected_symbols, result_symbols)
def test_aima_example(self): parser = PLParser() sentence = parser.parse("B11 <=> (P12 OR P21)") transformer = CNFTransformer() cnf = transformer.transform(sentence) self._test_gatherer(cnf, [ OrTerm(NotTerm(SymbolTerm("B11")), OrTerm(SymbolTerm("P12"), SymbolTerm("P21"))), OrTerm(NotTerm(SymbolTerm("P12")), SymbolTerm("B11")), OrTerm(NotTerm(SymbolTerm("P21")), SymbolTerm("B11")) ])
def test_not(self): expression = "NOT A" parser = PLParser() root_term = parser.parse(expression) m = Model() m = m.extend("A", False) self.assertTrue(m.is_true(root_term)) m.clear() m = m.extend("A", True) self.assertFalse(m.is_true(root_term))
def test_dpll_when_all_clauses_true(self): model = Model() model = model.extend("A", True).extend("B", True) sentence = PLParser().parse("(A OR B) AND (A OR B)") result = DPLL().dpll_satisfiable(sentence, model) self.assertTrue(result)
def _test_resolution(self, expression, question, expected_result): kb = KnowledgeBase() kb.tell_str(expression) question_term = PLParser().parse(question) pl_resolution = PLResolution() result = pl_resolution.pl_resolution(kb, question_term) self.assertEquals(expected_result, result)
def _test_plfc_entails(self, expressions, question, expected_result): kb = KnowledgeBase() kb.tell_all_str(expressions) question_sentence = PLParser().parse(question) plfc_entails = PLFCEntails() result = plfc_entails.plfc_entails(kb, question_sentence) self.assertEquals(expected_result, result)
def _test_gatherer(self, expression, expected_symbols, expected_not_symbols=set()): sentence = PLParser().parse(expression) (symbols, not_symbols) = CNFOrGatherer().collect(sentence) self.assertSetEqual(expected_symbols, symbols) self.assertSetEqual(not_symbols, expected_not_symbols)
def tt_entails(self, knowledge_base, alpha): kb_sentence = knowledge_base.as_sentence() query_sentence = PLParser().parse(alpha) collector = SymbolsCollector() kb_symbols = collector.collect_symbols(kb_sentence) query_symbols = collector.collect_symbols(query_sentence) # symbols <- a list of proposition symbols in KB and alpha symbols_list = list(kb_symbols.union(query_symbols)) # return TT-Check-All(KB, alpha, symbols, []) return self.tt_check_all(kb_sentence, query_sentence, symbols_list, Model())
def _test_gatherer_str(self, expression, expected_clauses): parser = PLParser() sentence = parser.parse(expression) self._test_gatherer(sentence, expected_clauses)
def test_dpll_succeeds_with_a_and_not_a(self): sentence = PLParser().parse("A AND (NOT A)") result = DPLL().dpll_satisfiable(sentence) self.assertFalse(result)
def test_dpll_return_false_with_one_false_in_model(self): model = Model().extend("A", True).extend("B", False) sentence = PLParser().parse("(A OR B) AND (A => B)") result = DPLL().dpll_satisfiable(sentence, model) self.assertFalse(result)
class KnowledgeBase: """ Knowledge base that stores information in propositional logic """ def __init__(self): self.sentences = [] self.parser = PLParser() def tell_str(self, str): """ Add new statement in to knowledge base :param str (str): Propositional logic expression :return: None """ sentence = self.parser.parse(str) self.tell(sentence) def tell(self, term): """ Add new statement to knowledge base :param term (Term): Root term of propositional logic expression :return: None """ self.sentences.append(term) def tell_all_str(self, strs): """ Add several statements to knowledge base :param strs (iterable(str)): Experssions to add to knowledge base :return: None """ for str in strs: self.tell_str(str) def tell_all(self, terms): """ Add all expressions to knowledge base :param terms (iterable(Term)): root terms of expressions that should be added to knowledge base :return: None """ for term in terms: self.tell(term) def size(self): """ Get number of statements in knowledge base :return (int): number of expressions in knowledge base """ return len(self.sentences) def as_sentence(self): """ Get all statements connected by AND operator as a single sentence. For example if there are expressions "A", "B", "NOT C", this will return A AND B AND (NOT C) :return (Term): root term of connected statements if any statements added to the knowledge base, None otherwise """ return create_symbols_connection(AndTerm, self.sentences, None) def ask_with_dpll(self, question): return not DPLL().dpll_satisfiable( AndTerm(self.as_sentence(), question))
def _test_transformer(self, input, expected_result): parser = PLParser() sentence = parser.parse(input) result = CNFTransformer().transform(sentence) self.assertEqual(expected_result, result)
def __init__(self): self.sentences = [] self.parser = PLParser()
def _test_parser(self, str, expected_term): parser = PLParser() result_term = parser.parse(str) self.assertEqual(expected_term, result_term)