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_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_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_parser(self, str, expected_term): parser = PLParser() result_term = parser.parse(str) self.assertEqual(expected_term, result_term)
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_gatherer_str(self, expression, expected_clauses): parser = PLParser() sentence = parser.parse(expression) self._test_gatherer(sentence, expected_clauses)
def _test_transformer(self, input, expected_result): parser = PLParser() sentence = parser.parse(input) result = CNFTransformer().transform(sentence) self.assertEqual(expected_result, 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))