/
Test.py
163 lines (126 loc) · 7.91 KB
/
Test.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
import unittest
import Lex
import Parse
import Eval
class LexTest(unittest.TestCase):
def test_lex(self):
self.assertEqual(Lex.lex("test"), ["test"])
self.assertEqual(Lex.lex("if (*p1-- == *p2++) then f() else g()"),
["if", "(", "*", "p1", "--", "==", "*", "p2", "++", ")", "then", "f", "(", ")", "else", "g", "(", ")"])
self.assertEqual(Lex.lex("((("), ["(", "(", "("])
self.assertEqual(Lex.lex("if (*p1--55 == *p2++) then f() else g()"),
["if", "(", "*", "p1", "--", "55", "==", "*", "p2", "++", ")", "then", "f", "(", ")", "else", "g", "(", ")"])
self.assertEqual(Lex.lex("55 aa5"), ["55", "aa5"])
def test_lexwhile(self):
self.assertEqual(Lex.lexwhile(str.isalnum, "asfafsasf13((("), ("asfafsasf13", "((("))
self.assertEqual(Lex.lexwhile(str.isalnum, "((("), ("", "((("))
class ParseTest(unittest.TestCase):
def test_tokens(self):
pass
#self.assertEqual(Parse.createTokens(Lex.lex("true /\\ false")),
# [Parse.Token(Parse.typeVar, "true"), Parse.Token(Parse.typeDual, "/\\"), Parse.Token(Parse.typeVar, "false")])
#self.assertEqual(Parse.createTokens(Lex.lex("~var")), [Parse.Token(Parse.typeSingle, "~"), Parse.Token(Parse.typeVar, "var")])
def test_parse(self):
parser = Parse.ParseTreeGenertor()
#self.assertEquals(parser.parse("b <=> (a <=> ~a)"), ('<=>', 'b', ('<=>', 'a', ('~', 'a'))))
self.assertEquals(parser.parse("~((a => ((b /\\ c) \\/ d \\/ e) <=> true))"), (Parse.str_to_tok('~'), (Parse.str_to_tok("=>"), Parse.str_to_tok("a"), (Parse.str_to_tok("<=>"), (Parse.str_to_tok("\\/"), (Parse.str_to_tok("/\\"), Parse.str_to_tok("b"), Parse.str_to_tok("c")), (Parse.str_to_tok("\\/"), Parse.str_to_tok("d"), Parse.str_to_tok("e"))), Parse.str_to_tok("true")))))
self.assertEquals(Parse.parse("true"), (Parse.str_to_tok("true")))
def test_parse_priority(self):
parser = Parse.ParseTreeGenertor()
#self.assertEquals(parser.parse("a <=> b => c"), ("=>", ("<=>", "a", "b"), "c"))
class EvalTest(unittest.TestCase):
def test_atoms(self):
parser = Parse.ParseTreeGenertor()
self.assertEquals(Eval.atoms(parser.parse("~((a => ((b /\\ c) \\/ d \\/ e) <=> f))")), {'a', 'b', 'c', 'd', 'e', 'f'})
self.assertEquals(Eval.atoms(parser.parse("~((a => ((b /\\ c) \\/ d \\/ e) <=> true))")), {'a', 'b', 'c', 'd', 'e'})
def test_eval_by_def(self):
self.assertFalse(Eval.eval(Parse.parse("a \\/ b"), {"a": False, "b": False}))
self.assertTrue(Eval.eval(Parse.parse("a \\/ b"), {"a": False, "b": True}))
self.assertTrue(Eval.eval(Parse.parse("a \\/ b"), {"a": True, "b": False}))
self.assertTrue(Eval.eval(Parse.parse("a \\/ b"), {"a": True, "b": True}))
self.assertFalse(Eval.eval(Parse.parse("a \\/ a"), {"a": False}))
self.assertTrue(Eval.eval(Parse.parse("a \\/ a"), {"a": True}))
self.assertFalse(Eval.eval(Parse.parse("a /\\ b"), {"a": False, "b": False}))
self.assertFalse(Eval.eval(Parse.parse("a /\\ b"), {"a": False, "b": True}))
self.assertFalse(Eval.eval(Parse.parse("a /\\ b"), {"a": True, "b": False}))
self.assertTrue(Eval.eval(Parse.parse("a /\\ b"), {"a": True, "b": True}))
self.assertFalse(Eval.eval(Parse.parse("a /\\ a"), {"a": False}))
self.assertTrue(Eval.eval(Parse.parse("a /\\ a"), {"a": True}))
self.assertFalse(Eval.eval(Parse.parse("a => b"), {"a": True, "b": False}))
self.assertTrue(Eval.eval(Parse.parse("a => b"), {"a": True, "b": True}))
self.assertTrue(Eval.eval(Parse.parse("a => b"), {"a": False, "b": True}))
self.assertTrue(Eval.eval(Parse.parse("a => b"), {"a": False, "b": False}))
self.assertTrue(Eval.eval(Parse.parse("a <=> b"), {"a": False, "b": False}))
self.assertFalse(Eval.eval(Parse.parse("a <=> b"), {"a": False, "b": True}))
self.assertFalse(Eval.eval(Parse.parse("a <=> b"), {"a": True, "b": False}))
self.assertTrue(Eval.eval(Parse.parse("a <=> b"), {"a": True, "b": True}))
self.assertTrue(Eval.eval(Parse.parse("~a"), {"a": False}))
self.assertTrue(Eval.eval(Parse.parse("~a \\/ b"), {"a": False, "b": False}))
self.assertTrue(Eval.eval(Parse.parse("~a \\/ b"), {"a": False, "b": True}))
self.assertFalse(Eval.eval(Parse.parse("~a \\/ b"), {"a": True, "b": False}))
self.assertTrue(Eval.eval(Parse.parse("~a \\/ b"), {"a": True, "b": True}))
def test_eval_complex(self):
self.assertFalse(Eval.eval(Parse.parse("a /\\ ~(a <=> a)"), {"a": False}))
self.assertFalse(Eval.eval(Parse.parse("a /\\ ~(a <=> a)"), {"a": True}))
self.assertTrue(Eval.eval(Parse.parse("(Smoke => Fire) => (~Smoke => ~Fire)"), {"Smoke": False, "Fire": False}))
self.assertFalse(Eval.eval(Parse.parse("(Smoke => Fire) => (~Smoke => ~Fire)"), {"Smoke": False, "Fire": True}))
self.assertTrue(Eval.eval(Parse.parse("(Smoke => Fire) => (~Smoke => ~Fire)"), {"Smoke": True, "Fire": False}))
self.assertTrue(Eval.eval(Parse.parse("(Smoke => Fire) => (~Smoke => ~Fire)"), {"Smoke": True, "Fire": True}))
self.assertTrue(Eval.eval(Parse.parse("a /\\ (b \\/ c)"), {"a": True, "b": False, "c": True}))
self.assertFalse(Eval.eval(Parse.parse("(a /\\ b) \\/ c"), {"a": True, "b": False, "c": False}))
def test_eval_simple(self):
self.assertTrue(Eval.eval(Parse.parse("true"), {}))
self.assertFalse(Eval.eval(Parse.parse("false"), {}))
def test_all_valuations(self):
self.assertEquals(list(Eval.all_valuations(["a", "b"])), [
{"a": False, "b": False},
{"a": False, "b": True},
{"a": True, "b": False},
{"a": True, "b": True},
])
self.assertEquals(len(list(Eval.all_valuations(["a", "b"]))), 2 ** 2)
self.assertEquals(len(list(Eval.all_valuations(["a", "b", "c"]))), 2 ** 3)
self.assertEquals(len(list(Eval.all_valuations(["a", "b", "c", "d"]))), 2 ** 4)
def test_tautology(self):
self.assertFalse(Eval.tautology("a /\\ b"))
self.assertTrue(Eval.tautology("a <=> a"))
self.assertFalse(Eval.tautology("a <=> b"))
def test_satisfiable(self):
self.assertTrue(Eval.satisfiable("a /\\ b"))
self.assertFalse(Eval.satisfiable("a /\\ ~a"))
class ExerciseTest(unittest.TestCase):
def test_exercise41(self):
self.assertTrue(Eval.entails("False", "True"))
self.assertFalse(Eval.entails("True", "False"))
self.assertTrue(Eval.entails("a /\\ b", "a <=> b"))
self.assertFalse(Eval.entails("a <=> b", "a \\/ b"))
self.assertTrue(Eval.entails("a <=> b", "~a \\/ b"))
def test_exercise42(self):
f1 = "Smoke => Smoke"
self.assertTrue(Eval.satisfiable(f1))
self.assertFalse(Eval.unsatisfiable(f1))
self.assertTrue(Eval.tautology(f1))
f1 = "(Smoke => Fire) => (~Smoke => ~Fire)"
self.assertTrue(Eval.satisfiable(f1))
self.assertFalse(Eval.unsatisfiable(f1))
self.assertFalse(Eval.tautology(f1))
f1 = "Smoke \\/ Fire\\/ ~Fire"
self.assertTrue(Eval.satisfiable(f1))
self.assertFalse(Eval.unsatisfiable(f1))
self.assertTrue(Eval.tautology(f1))
f1 = "(Fire => Smoke) /\\ Fire /\\ ~Smoke"
self.assertFalse(Eval.satisfiable(f1))
self.assertTrue(Eval.unsatisfiable(f1))
self.assertFalse(Eval.tautology(f1))
def test_exercise43(self):
bsays = "b <=> (a <=> ~a)"
csays = "c <=> ~b"
kb = "(%s) /\\ (%s) " % (bsays, csays)
self.assertFalse(Eval.entails(kb, "a"))
self.assertFalse(Eval.entails(kb, "~a"))
self.assertFalse(Eval.entails(kb, "b"))
self.assertTrue(Eval.entails(kb, "~b"))
self.assertTrue(Eval.entails(kb, "c"))
self.assertFalse(Eval.entails(kb, "~c"))
def test_questoin423(self):
self.assertFalse(Eval.tautology("~(kb /\ ~A) => (kb /\ A)"))