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_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_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_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_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))
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)
def _test_parser(self, str, expected_term):
parser = PLParser()
result_term = parser.parse(str)
self.assertEqual(expected_term, result_term)
