truth table: tests and solutions

Nullary and Unary Operations: tests and solutions

Nullary and Unary Operations: tests

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

truth_table/tests/test_nullary_unary.py
 1import src.truth_table
 2import unittest
 3
 4
 5class TestNullaryOperations(unittest.TestCase):
 6
 7    def test_logical_true(self):
 8        self.assertTrue(
 9            src.truth_table.logical_true()
10        )
11
12    def test_logical_false(self):
13        self.assertFalse(
14            src.truth_table.logical_false()
15        )
16
17
18class TestUnaryOperations(unittest.TestCase):
19
20    def test_logical_identity(self):
21        self.assertTrue(
22            src.truth_table.logical_identity(True)
23        )
24        self.assertFalse(
25            src.truth_table.logical_identity(False)
26        )
27
28    def test_logical_negation_aka_not(self):
29        self.assertFalse(
30            src.truth_table.logical_negation(True)
31        )
32        self.assertTrue(
33            src.truth_table.logical_negation(False)
34        )
35
36
37# Exceptions seen
38# AssertionError
39# AttributeError
40# TypeError

Nullary and Unary Operations: solutions

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

truth_table/src/truth_table.py
 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

Binary Operations 1: tests and solutions

Binary Operations 1: tests

the code in truth_table/tests/test_binary.py from truth table: Binary Operations 1

truth_table/src/truth_table.py
 1import src.truth_table
 2import unittest
 3
 4
 5class TestBinaryOperations(unittest.TestCase):
 6
 7    def test_contradiction(self):
 8        contradiction = src.truth_table.contradiction
 9        self.assertFalse(contradiction(True, True))
10        self.assertFalse(contradiction(True, False))
11        self.assertFalse(contradiction(False, True))
12        self.assertFalse(contradiction(False, False))
13
14    def test_logical_conjunction(self):
15        logical_conjunction = (
16            src.truth_table.logical_conjunction
17        )
18        self.assertTrue(logical_conjunction(True, True))
19        self.assertFalse(logical_conjunction(True, False))
20        self.assertFalse(logical_conjunction(False, True))
21        self.assertFalse(logical_conjunction(False, False))
22
23    def test_project_second(self):
24        project_second = src.truth_table.project_second
25        self.assertTrue(project_second(True, True))
26        self.assertFalse(project_second(True, False))
27        self.assertTrue(project_second(False, True))
28        self.assertFalse(project_second(False, False))
29
30    def test_converse_non_implication(self):
31        converse_non_implication = (
32            src.truth_table.converse_non_implication
33        )
34        self.assertFalse(converse_non_implication(True, True))
35        self.assertFalse(converse_non_implication(True, False))
36        self.assertTrue(converse_non_implication(False, True))
37        self.assertFalse(converse_non_implication(False, False))
38
39
40# Exceptions seen
41# AttributeError
42# TypeError
43# AssertionError

Binary Operations 1: solutions

the code in truth_table/src/test_binary.py from truth table: Binary Operations 1

truth_table/src/truth_table.py
 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, 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 logical_conjunction(
31        logical_negation(first_input),
32        second_input
33    )
34    return not first_input and second_input

Binary Operations 2: tests and solutions

Binary Operations 2: tests

the code in truth_table/tests/test_binary.py from truth table: Binary Operations 2

truth_table/src/truth_table.py
 1import src.truth_table
 2import unittest
 3
 4
 5class TestBinaryOperations(unittest.TestCase):
 6
 7    def test_contradiction(self):
 8        contradiction = src.truth_table.contradiction
 9        self.assertFalse(contradiction(True, True))
10        self.assertFalse(contradiction(True, False))
11        self.assertFalse(contradiction(False, True))
12        self.assertFalse(contradiction(False, False))
13
14    def test_logical_conjunction(self):
15        logical_conjunction = (
16            src.truth_table.logical_conjunction
17        )
18        self.assertTrue(logical_conjunction(True, True))
19        self.assertFalse(logical_conjunction(True, False))
20        self.assertFalse(logical_conjunction(False, True))
21        self.assertFalse(logical_conjunction(False, False))
22
23    def test_project_second(self):
24        project_second = src.truth_table.project_second
25        self.assertTrue(project_second(True, True))
26        self.assertFalse(project_second(True, False))
27        self.assertTrue(project_second(False, True))
28        self.assertFalse(project_second(False, False))
29
30    def test_converse_non_implication(self):
31        converse_non_implication = (
32            src.truth_table.converse_non_implication
33        )
34        self.assertFalse(converse_non_implication(True, True))
35        self.assertFalse(converse_non_implication(True, False))
36        self.assertTrue(converse_non_implication(False, True))
37        self.assertFalse(converse_non_implication(False, False))
38
39    def test_negate_first(self):
40        negate_first = src.truth_table.negate_first
41        self.assertFalse(negate_first(True, True))
42        self.assertFalse(negate_first(True, False))
43        self.assertTrue(negate_first(False, True))
44        self.assertTrue(negate_first(False, False))
45
46    def test_logical_nand(self):
47        nand = src.truth_table.logical_nand
48        self.assertFalse(nand(True, True))
49        self.assertTrue(nand(True, False))
50        self.assertTrue(nand(False, True))
51        self.assertTrue(nand(False, False))
52
53    def test_tautology(self):
54        tautology = src.truth_table.tautology
55        self.assertTrue(tautology(True, True))
56        self.assertTrue(tautology(True, False))
57        self.assertTrue(tautology(False, True))
58        self.assertTrue(tautology(False, False))
59
60    def test_logical_disjunction(self):
61        logical_disjunction = (
62            src.truth_table.logical_disjunction
63        )
64        self.assertTrue(logical_disjunction(True, True))
65        self.assertTrue(logical_disjunction(True, False))
66        self.assertTrue(logical_disjunction(False, True))
67        self.assertFalse(logical_disjunction(False, False))
68
69
70# Exceptions seen
71# AttributeError
72# TypeError
73# AssertionError
74# SyntaxError

Binary Operations 2: solutions

the code in truth_table/src/test_binary.py from truth table: Binary Operations 2

truth_table/src/truth_table.py
 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, 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 logical_conjunction(
31        logical_negation(first_input),
32        second_input
33    )
34    return not first_input and second_input
35
36
37def negate_first(first_input, second_input):
38    return not first_input
39
40
41def logical_nand(first_input, second_input):
42    return logical_negation(
43        logical_conjunction(first_input, second_input)
44    )
45    return not (first_input and second_input)
46
47
48def tautology(first_input, second_input):
49    return True
50
51
52def logical_disjunction(first_input, second_input):
53    return logical_negation(
54        logical_conjunction(
55            logical_negation(first_input),
56            logical_negation(second_input)
57        )
58    )
59    return first_input or second_input

Binary Operations 3: tests and solutions

Binary Operations 3: tests

the code in truth_table/tests/test_binary.py from truth table: Binary Operations 3

truth_table/tests/test_binary.py
  1import src.truth_table
  2import unittest
  3
  4
  5class TestBinaryOperations(unittest.TestCase):
  6
  7    def test_contradiction(self):
  8        contradiction = src.truth_table.contradiction
  9        self.assertFalse(contradiction(True, True))
 10        self.assertFalse(contradiction(True, False))
 11        self.assertFalse(contradiction(False, True))
 12        self.assertFalse(contradiction(False, False))
 13
 14    def test_logical_conjunction(self):
 15        logical_conjunction = (
 16            src.truth_table.logical_conjunction
 17        )
 18        self.assertTrue(logical_conjunction(True, True))
 19        self.assertFalse(logical_conjunction(True, False))
 20        self.assertFalse(logical_conjunction(False, True))
 21        self.assertFalse(logical_conjunction(False, False))
 22
 23    def test_project_second(self):
 24        project_second = src.truth_table.project_second
 25        self.assertTrue(project_second(True, True))
 26        self.assertFalse(project_second(True, False))
 27        self.assertTrue(project_second(False, True))
 28        self.assertFalse(project_second(False, False))
 29
 30    def test_converse_non_implication(self):
 31        converse_non_implication = (
 32            src.truth_table.converse_non_implication
 33        )
 34        self.assertFalse(converse_non_implication(True, True))
 35        self.assertFalse(converse_non_implication(True, False))
 36        self.assertTrue(converse_non_implication(False, True))
 37        self.assertFalse(converse_non_implication(False, False))
 38
 39    def test_negate_first(self):
 40        negate_first = src.truth_table.negate_first
 41        self.assertFalse(negate_first(True, True))
 42        self.assertFalse(negate_first(True, False))
 43        self.assertTrue(negate_first(False, True))
 44        self.assertTrue(negate_first(False, False))
 45
 46    def test_logical_nand(self):
 47        nand = src.truth_table.logical_nand
 48        self.assertFalse(nand(True, True))
 49        self.assertTrue(nand(True, False))
 50        self.assertTrue(nand(False, True))
 51        self.assertTrue(nand(False, False))
 52
 53    def test_tautology(self):
 54        tautology = src.truth_table.tautology
 55        self.assertTrue(tautology(True, True))
 56        self.assertTrue(tautology(True, False))
 57        self.assertTrue(tautology(False, True))
 58        self.assertTrue(tautology(False, False))
 59
 60    def test_logical_disjunction(self):
 61        logical_disjunction = (
 62            src.truth_table.logical_disjunction
 63        )
 64        self.assertTrue(logical_disjunction(True, True))
 65        self.assertTrue(logical_disjunction(True, False))
 66        self.assertTrue(logical_disjunction(False, True))
 67        self.assertFalse(logical_disjunction(False, False))
 68
 69    def test_exclusive_disjunction(self):
 70        xor = src.truth_table.exclusive_disjunction
 71        self.assertFalse(xor(True, True))
 72        self.assertTrue(xor(True, False))
 73        self.assertTrue(xor(False, True))
 74        self.assertFalse(xor(False, False))
 75
 76    def test_material_non_implication(self):
 77        material_non_implication = (
 78            src.truth_table.material_non_implication
 79        )
 80        self.assertFalse(material_non_implication(True, True))
 81        self.assertTrue(material_non_implication(True, False))
 82        self.assertFalse(material_non_implication(False, True))
 83        self.assertFalse(material_non_implication(False, False))
 84
 85    def test_project_first(self):
 86        project_first = src.truth_table.project_first
 87        self.assertTrue(project_first(True, True))
 88        self.assertTrue(project_first(True, False))
 89        self.assertFalse(project_first(False, True))
 90        self.assertFalse(project_first(False, False))
 91
 92    def test_converse_implication(self):
 93        converse_implication = (
 94            src.truth_table.converse_implication
 95        )
 96        self.assertTrue(converse_implication(True, True))
 97        self.assertTrue(converse_implication(True, False))
 98        self.assertFalse(converse_implication(False, True))
 99        self.assertTrue(converse_implication(False, False))
100
101
102# Exceptions seen
103# AttributeError
104# TypeError
105# AssertionError
106# SyntaxError

Binary Operations 3: solutions

the code in truth_table/src/truth_table.py from truth table: Binary Operations 3

truth_table/src/truth_table.py
 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, 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 logical_conjunction(
31        logical_negation(first_input),
32        second_input
33    )
34    return not first_input and second_input
35
36
37def negate_first(first_input, second_input):
38    return not first_input
39
40
41def logical_nand(first_input, second_input):
42    return logical_negation(
43        logical_conjunction(first_input, second_input)
44    )
45    return not (first_input and second_input)
46
47
48def tautology(first_input, second_input):
49    return True
50
51
52def logical_disjunction(first_input, second_input):
53    return logical_negation(
54        logical_conjunction(
55            logical_negation(first_input),
56            logical_negation(second_input)
57        )
58    )
59    return first_input or second_input
60
61
62def exclusive_disjunction(first_input, second_input):
63    return first_input != second_input
64    return not (first_input == second_input)
65    return logical_disjunction(
66        converse_non_implication(
67            first_input, second_input
68        ),
69        material_non_implication(
70            first_input, second_input
71        )
72    )
73    return (
74        (not first_input and second_input)
75        or
76        (first_input and not second_input)
77    )
78
79
80def material_non_implication(first_input, second_input):
81    return logical_conjunction(
82        first_input,
83        logical_negation(second_input)
84    )
85    return first_input and not second_input
86
87
88def project_first(first_input, second_input):
89    return first_input
90
91
92def converse_implication(first_input, second_input):
93    return logical_disjunction(
94        first_input,
95        logical_negation(second_input)
96    )
97    return first_input or not second_input

Binary Operations: tests and solutions

Binary Operations: tests

the code in truth_table/tests/test_binary.py from truth table: Binary Operations 4

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

Binary Operations: solutions

the code in truth_table/src/truth_table.py from truth table: Binary Operations 4

truth_table/src/truth_table.py
  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, 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 logical_conjunction(
 31        logical_negation(first_input),
 32        second_input
 33    )
 34    return not first_input and second_input
 35
 36
 37def negate_first(first_input, second_input):
 38    return not first_input
 39
 40
 41def logical_nand(first_input, second_input):
 42    return logical_negation(
 43        logical_conjunction(first_input, second_input)
 44    )
 45    return not (first_input and second_input)
 46
 47
 48def tautology(first_input, second_input):
 49    return True
 50
 51
 52def logical_disjunction(first_input, second_input):
 53    return logical_negation(
 54        logical_conjunction(
 55            logical_negation(first_input),
 56            logical_negation(second_input)
 57        )
 58    )
 59    return first_input or second_input
 60
 61
 62def exclusive_disjunction(first_input, second_input):
 63    return first_input != second_input
 64    return not (first_input == second_input)
 65    return logical_disjunction(
 66        converse_non_implication(
 67            first_input, second_input
 68        ),
 69        material_non_implication(
 70            first_input, second_input
 71        )
 72    )
 73    return (
 74        (not first_input and second_input)
 75        or
 76        (first_input and not second_input)
 77    )
 78
 79
 80def material_non_implication(first_input, second_input):
 81    return logical_conjunction(
 82        first_input,
 83        logical_negation(second_input)
 84    )
 85    return first_input and not second_input
 86
 87
 88def project_first(first_input, second_input):
 89    return first_input
 90
 91
 92def converse_implication(first_input, second_input):
 93    return logical_disjunction(
 94        first_input,
 95        logical_negation(second_input)
 96    )
 97    return first_input or not second_input
 98
 99
100def negate_second(first_input, second_input):
101    return not second_input
102
103
104def logical_nor(first_input, second_input):
105    return logical_negation(
106        logical_disjunction(
107            first_input, second_input
108        )
109    )
110    return not (first_input or second_input)
111
112
113def logical_equality(first_input, second_input):
114    return first_input == second_input
115    return logical_disjunction(
116        logical_conjunction(first_input, second_input),
117        logical_nor(first_input, second_input)
118    )
119    return (
120        (first_input and second_input)
121        or
122        not (first_input or second_input)
123    )
124
125
126def material_implication(first_input, second_input):
127    return logical_disjunction(
128        logical_negation(first_input),
129        second_input
130    )
131    return not first_input or second_input

Truth Table tests: solutions

the code in truth_table/src/truth_table.py from truth table: test_truth_table_tests

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