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)
