truth table: tests and solutions

Nullary and Unary Operations tests

the code in truth_table/tests/test_binary.py from truth table: Nullary and Unary Operations

 1import src.truth_table
 2import unittest
 3
 4
 5class TestNullaryOperations(unittest.TestCase):
 6
 7    def test_logical_true(self):
 8        self.assertTrue(src.truth_table.logical_true())
 9
10    def test_logical_false(self):
11        self.assertFalse(src.truth_table.logical_false())
12
13
14class TestUnaryOperations(unittest.TestCase):
15
16    def test_logical_identity(self):
17        self.assertTrue(src.truth_table.logical_identity(True))
18        self.assertFalse(src.truth_table.logical_identity(False))
19
20    def test_logical_negation_aka_not(self):
21        self.assertFalse(src.truth_table.logical_negation(True))
22        self.assertTrue(src.truth_table.logical_negation(False))
23
24
25# Exceptions seen
26# AssertionError
27# AttributeError
28# TypeError

Binary Operations tests

the code in truth_table/tests/test_binary.py from truth table

  1import src.truth_table
  2import unittest
  3
  4
  5class TestBinaryOperations(unittest.TestCase):
  6
  7    def test_contradiction(self):
  8        self.assertFalse(
  9            src.truth_table.contradiction(True, True)
 10        )
 11        self.assertFalse(
 12            src.truth_table.contradiction(True, False)
 13        )
 14        self.assertFalse(
 15            src.truth_table.contradiction(False, True)
 16        )
 17        self.assertFalse(
 18            src.truth_table.contradiction(False, False)
 19        )
 20
 21    def test_logical_conjunction(self):
 22        self.assertTrue(
 23            src.truth_table.logical_conjunction(True, True)
 24        )
 25        self.assertFalse(
 26            src.truth_table.logical_conjunction(True, False)
 27        )
 28        self.assertFalse(
 29            src.truth_table.logical_conjunction(False, True)
 30        )
 31        self.assertFalse(
 32            src.truth_table.logical_conjunction(False, False)
 33        )
 34
 35    def test_project_second(self):
 36        self.assertTrue(
 37            src.truth_table.project_second(True, True)
 38        )
 39        self.assertFalse(
 40            src.truth_table.project_second(True, False)
 41        )
 42        self.assertTrue(
 43            src.truth_table.project_second(False, True)
 44        )
 45        self.assertFalse(
 46            src.truth_table.project_second(False, False)
 47        )
 48
 49    def test_converse_non_implication(self):
 50        self.assertFalse(
 51            src.truth_table.converse_non_implication(True, True)
 52        )
 53        self.assertFalse(
 54            src.truth_table.converse_non_implication(True, False)
 55        )
 56        self.assertTrue(
 57            src.truth_table.converse_non_implication(False, True)
 58        )
 59        self.assertFalse(
 60            src.truth_table.converse_non_implication(False, False)
 61        )
 62
 63    def test_negate_first(self):
 64        self.assertFalse(src.truth_table.negate_first(True, True))
 65        self.assertFalse(src.truth_table.negate_first(True, False))
 66        self.assertTrue(src.truth_table.negate_first(False, True))
 67        self.assertTrue(src.truth_table.negate_first(False, False))
 68
 69    def test_logical_nand(self):
 70        self.assertFalse(src.truth_table.logical_nand(True, True))
 71        self.assertTrue(src.truth_table.logical_nand(True, False))
 72        self.assertTrue(src.truth_table.logical_nand(False, True))
 73        self.assertTrue(src.truth_table.logical_nand(False, False))
 74
 75    def test_tautology(self):
 76        self.assertTrue(src.truth_table.tautology(True, True))
 77        self.assertTrue(src.truth_table.tautology(True, False))
 78        self.assertTrue(src.truth_table.tautology(False, True))
 79        self.assertTrue(src.truth_table.tautology(False, False))
 80
 81    def test_logical_disjunction(self):
 82        self.assertTrue(
 83            src.truth_table.logical_disjunction(True, True)
 84        )
 85        self.assertTrue(
 86            src.truth_table.logical_disjunction(True, False)
 87        )
 88        self.assertTrue(
 89            src.truth_table.logical_disjunction(False, True)
 90        )
 91        self.assertFalse(
 92            src.truth_table.logical_disjunction(False, False)
 93        )
 94
 95    def test_exclusive_disjunction(self):
 96        self.assertFalse(src.truth_table.exclusive_disjunction(True, True))
 97        self.assertTrue(src.truth_table.exclusive_disjunction(True, False))
 98        self.assertTrue(src.truth_table.exclusive_disjunction(False, True))
 99        self.assertFalse(src.truth_table.exclusive_disjunction(False, False))
100
101    def test_material_non_implication(self):
102        self.assertFalse(
103            src.truth_table.material_non_implication(True, True)
104        )
105        self.assertTrue(
106            src.truth_table.material_non_implication(True, False)
107        )
108        self.assertFalse(
109            src.truth_table.material_non_implication(False, True)
110        )
111        self.assertFalse(
112            src.truth_table.material_non_implication(False, False)
113        )
114
115    def test_project_first(self):
116        self.assertTrue(src.truth_table.project_first(True, True))
117        self.assertTrue(src.truth_table.project_first(True, False))
118        self.assertFalse(src.truth_table.project_first(False, True))
119        self.assertFalse(src.truth_table.project_first(False, False))
120
121    def test_converse_implication(self):
122        self.assertTrue(src.truth_table.converse_implication(True, True))
123        self.assertTrue(src.truth_table.converse_implication(True, False))
124        self.assertFalse(src.truth_table.converse_implication(False, True))
125        self.assertTrue(src.truth_table.converse_implication(False, False))
126
127    def test_negate_second(self):
128        self.assertFalse(src.truth_table.negate_second(True, True))
129        self.assertTrue(src.truth_table.negate_second(True, False))
130        self.assertFalse(src.truth_table.negate_second(False, True))
131        self.assertTrue(src.truth_table.negate_second(False, False))
132
133    def test_logical_nor(self):
134        self.assertFalse(src.truth_table.logical_nor(True, True))
135        self.assertFalse(src.truth_table.logical_nor(True, False))
136        self.assertFalse(src.truth_table.logical_nor(False, True))
137        self.assertTrue(src.truth_table.logical_nor(False, False))
138
139    def test_logical_equality(self):
140        self.assertTrue(src.truth_table.logical_equality(True, True))
141        self.assertFalse(src.truth_table.logical_equality(True, False))
142        self.assertFalse(src.truth_table.logical_equality(False, True))
143        self.assertTrue(src.truth_table.logical_equality(False, False))
144
145    def test_material_implication(self):
146        self.assertTrue(src.truth_table.material_implication(True, True))
147        self.assertFalse(src.truth_table.material_implication(True, False))
148        self.assertTrue(src.truth_table.material_implication(False, True))
149        self.assertTrue(src.truth_table.material_implication(False, False))
150
151
152# Exceptions seen
153# AttributeError
154# TypeError
155# AssertionError
156# SyntaxError

Booleans 2 tests

the code in booleans/tests/test_booleans.py from booleans 2

 1import unittest
 2
 3
 4class TestBooleans(unittest.TestCase):
 5
 6    def test_what_is_false(self):
 7        self.assertIsInstance(False, bool)
 8        self.assertFalse(False)
 9        self.assertFalse(None)
10        self.assertFalse(bool(None))
11        self.assertFalse(0)
12        self.assertFalse(bool(0))
13        self.assertFalse(0.0)
14        self.assertFalse(bool(0.0))
15        self.assertFalse(str())
16        self.assertFalse(bool(str()))
17        self.assertFalse(tuple())
18        self.assertFalse(bool(tuple()))
19        self.assertFalse(list())
20        self.assertFalse(bool(list()))
21        self.assertFalse(set())
22        self.assertFalse(bool(set()))
23        self.assertFalse(dict())
24        self.assertFalse(bool(dict()))
25
26    def test_what_is_true(self):
27        self.assertIsInstance(True, bool)
28        self.assertTrue(True)
29        self.assertTrue(-1)
30        self.assertTrue(bool(-1))
31        self.assertTrue(1)
32        self.assertTrue(bool(1))
33        self.assertTrue(-0.1)
34        self.assertTrue(bool(-0.1))
35        self.assertTrue(0.1)
36        self.assertTrue(bool(0.1))
37        self.assertTrue("text")
38        self.assertTrue(bool("text"))
39        self.assertTrue((1, 2, 3, 'n'))
40        self.assertTrue(bool((1, 2, 3, 'n')))
41        self.assertTrue([1, 2, 3, 'n'])
42        self.assertTrue(bool([1, 2, 3, 'n']))
43        self.assertTrue({1, 2, 3, 'n'})
44        self.assertTrue(bool({1, 2, 3, 'n'}))
45        self.assertTrue({'key': 'value'})
46        self.assertTrue(bool({'key': 'value'}))
47
48
49# NOTES
50# a dictionary with things is True
51# a set with things is True
52# a list with things is True
53# a tuple with things is True
54# a string with things is True
55# positive and negative numbers are True
56# True is True
57# True is not false
58# True is a boolean
59# the empty dictionary is False
60# the empty set is False
61# the empty list is False
62# the empty tuple is False
63# the empty string is False
64# 0 is False
65# None is False
66# False is False
67# False is not true
68# False is a boolean
69
70
71# Exceptions seen
72# AssertionError

solutions

the solutions in truth_table/src/truth_table.py from truth table

 1def logical_true():
 2    return True
 3
 4
 5def logical_false():
 6    return False
 7
 8
 9def logical_identity(the_input):
10    return the_input
11
12
13def logical_negation(the_input):
14    return not the_input
15
16
17def contradiction(first_input, second_input):
18    return False
19
20
21def logical_conjunction(first_input, second_input):
22    return first_input and second_input
23
24
25def project_second(first_input, second_input):
26    return second_input
27
28
29def converse_non_implication(first_input, second_input):
30    return not first_input and second_input
31
32
33def negate_first(first_input, second_input):
34    return not first_input
35
36
37def logical_nand(first_input, second_input):
38    return not (first_input and second_input)
39
40
41def tautology(first_input, second_input):
42    return True
43
44
45def logical_disjunction(first_input, second_input):
46    return first_input or second_input
47
48
49def exclusive_disjunction(first_input, second_input):
50    return first_input != second_input
51    return not first_input == second_input
52    return (
53        (not first_input and second_input)
54        or
55        (first_input and not second_input)
56    )
57
58
59def material_non_implication(first_input, second_input):
60    return first_input and not second_input
61
62
63def project_first(first_input, second_input):
64    return first_input
65
66
67def converse_implication(first_input, second_input):
68    return first_input or not second_input
69
70
71def negate_second(first_input, second_input):
72    return not second_input
73
74
75def logical_nor(first_input, second_input):
76    return not (first_input or second_input)
77
78
79def logical_equality(first_input, second_input):
80    return first_input == second_input
81    return (
82        (first_input or not second_input)
83        and
84        (not first_input or second_input)
85    )
86
87
88def material_implication(first_input, second_input):
89    return not first_input or second_input