def test_unknown_symbol(self):
kb = KnowledgeBase()
kb.tell_str("(A => B) AND B")
tte = TTEntails()
result = tte.tt_entails(kb, "X")
self.assertFalse(result)
def test_simple_sentence3(self):
kb = KnowledgeBase()
kb.tell_str("(A => B) AND A")
tte = TTEntails()
result = tte.tt_entails(kb, "B")
self.assertTrue(result)
def test_simple_sentence6(self):
kb = KnowledgeBase()
kb.tell_str("NOT A")
tte = TTEntails()
result = tte.tt_entails(kb, "A")
self.assertFalse(result)
def test_simple_sentence6(self):
kb = KnowledgeBase()
kb.tell_str("NOT A")
tte = TTEntails()
result = tte.tt_entails(kb, "A")
self.assertFalse(result)
def test_unknown_symbol(self):
kb = KnowledgeBase()
kb.tell_str("(A => B) AND B")
tte = TTEntails()
result = tte.tt_entails(kb, "X")
self.assertFalse(result)
def test_simple_sentence3(self):
kb = KnowledgeBase()
kb.tell_str("(A => B) AND A")
tte = TTEntails()
result = tte.tt_entails(kb, "B")
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_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_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_as_sentence(self):
kb = KnowledgeBase()
kb.tell_str("A")
kb.tell_str("A OR B")
kb.tell_str("C <=> D")
kb.tell_str("E => NOT F")
sentence = kb.as_sentence()
expected_sentence = AndTerm(
SymbolTerm("A"),
AndTerm(
OrTerm(SymbolTerm("A"), SymbolTerm("B")),
AndTerm(
BiconditionalTerm(SymbolTerm("C"), SymbolTerm("D")),
ImplicationTerm(SymbolTerm("E"), NotTerm(SymbolTerm("F"))),
),
),
)
self.assertEqual(expected_sentence, sentence)
def test_dpll1(self):
kb = KnowledgeBase()
kb.tell_str("(B12 <=> (P11 OR (P13 OR (P22 OR P02))))")
kb.tell_str("(B21 <=> (P20 OR (P22 OR (P31 OR P11))))")
kb.tell_str("(B01 <=> (P00 OR (P02 OR P11)))")
kb.tell_str("(B10 <=> (P11 OR (P20 OR P00)))")
kb.tell_str("(NOT B21)")
kb.tell_str("(NOT B12)")
kb.tell_str("(B10)")
kb.tell_str("(B01)")
kb.ask_with_dpll(SymbolTerm("P00"))
kb.ask_with_dpll(NotTerm(SymbolTerm("P00")))
__author__ = 'Ivan Mushketik'
__docformat__ = 'restructuredtext en'
#
# Example of using WalkSAT algorithm
#
# Number of flips in a single WalkSAT algorithm
NUMBER_OF_FLIPS = 10000
# Probability of flipping symbol's value in a clause
WALK_SAT_PROBABILITY = 0.02
# Number of tries to solve a problem
NUMBER_OF_TRIES = 10
# Create a simple knowledge base from AIMA example
kb = KnowledgeBase()
kb.tell_str("NOT P11")
kb.tell_str("B11 <=> (P12 OR P21)")
kb.tell_str("B21 <=> (P11 OR P22 OR P31)")
kb.tell_str("NOT B11")
kb.tell_str("B21")
# Create sentence with all statements from knowledge base
sentence = kb.as_sentence()
# Create WalkSAT algorithm class
ws = WalkSat()
for i in range(NUMBER_OF_TRIES):
# Get result model. If solution was found it return Model object, or None otherwise
result_model = ws.find_model_for(AndTerm(sentence, SymbolTerm("P31")),
def test_aima_example(self):
kb = KnowledgeBase()
kb.tell_str("(NOT P11)")
kb.tell_str("(B11 <=> (P12 OR P21))")
kb.tell_str("(B21 <=> ((P11 OR P22) OR P31))")
kb.tell_str("(NOT B11)")
kb.tell_str("(B21)")
tte = TTEntails()
self.assertTrue(tte.tt_entails(kb, "NOT P12"))
self.assertFalse((tte.tt_entails(kb, "P22")))
def test_dpll1(self):
kb = KnowledgeBase()
kb.tell_str("(B12 <=> (P11 OR (P13 OR (P22 OR P02))))")
kb.tell_str("(B21 <=> (P20 OR (P22 OR (P31 OR P11))))")
kb.tell_str("(B01 <=> (P00 OR (P02 OR P11)))")
kb.tell_str("(B10 <=> (P11 OR (P20 OR P00)))")
kb.tell_str("(NOT B21)")
kb.tell_str("(NOT B12)")
kb.tell_str("(B10)")
kb.tell_str("(B01)")
kb.ask_with_dpll(SymbolTerm("P00"))
kb.ask_with_dpll(NotTerm(SymbolTerm("P00")))
def test_aima_example(self):
kb = KnowledgeBase()
kb.tell_str("(NOT P11)")
kb.tell_str("(B11 <=> (P12 OR P21))")
kb.tell_str("(B21 <=> ((P11 OR P22) OR P31))")
kb.tell_str("(NOT B11)")
kb.tell_str("(B21)")
tte = TTEntails()
self.assertTrue(tte.tt_entails(kb, "NOT P12"))
self.assertFalse((tte.tt_entails(kb, "P22")))
__author__ = 'Ivan Mushketik'
__docformat__ = 'restructuredtext en'
#
# Example of using WalkSAT algorithm
#
# Number of flips in a single WalkSAT algorithm
NUMBER_OF_FLIPS = 10000
# Probability of flipping symbol's value in a clause
WALK_SAT_PROBABILITY = 0.02
# Number of tries to solve a problem
NUMBER_OF_TRIES = 10
# Create a simple knowledge base from AIMA example
kb = KnowledgeBase()
kb.tell_str("NOT P11")
kb.tell_str("B11 <=> (P12 OR P21)")
kb.tell_str("B21 <=> (P11 OR P22 OR P31)")
kb.tell_str("NOT B11")
kb.tell_str("B21")
# Create sentence with all statements from knowledge base
sentence = kb.as_sentence()
# Create WalkSAT algorithm class
ws = WalkSat()
for i in range(NUMBER_OF_TRIES):
# Get result model. If solution was found it return Model object, or None otherwise
result_model = ws.find_model_for(AndTerm(sentence, SymbolTerm("P31")), NUMBER_OF_FLIPS, WALK_SAT_PROBABILITY)
def test_as_sentence(self):
kb = KnowledgeBase()
kb.tell_str("A")
kb.tell_str("A OR B")
kb.tell_str("C <=> D")
kb.tell_str("E => NOT F")
sentence = kb.as_sentence()
expected_sentence = AndTerm(
SymbolTerm("A"),
AndTerm(
OrTerm(SymbolTerm("A"), SymbolTerm("B")),
AndTerm(
BiconditionalTerm(SymbolTerm("C"), SymbolTerm("D")),
ImplicationTerm(SymbolTerm("E"),
NotTerm(SymbolTerm("F"))))))
self.assertEqual(expected_sentence, sentence)
