truth table: Binary Operations 4

requirements

preview

Here are the tests I have at the end of this chapter

import src.truth_table
import unittest


class TestBinaryOperations(unittest.TestCase):

    def test_contradiction(self):
        self.assertFalse(
            src.truth_table.contradiction(True, True)
        )
        self.assertFalse(
            src.truth_table.contradiction(True, False)
        )
        self.assertFalse(
            src.truth_table.contradiction(False, True)
        )
        self.assertFalse(
            src.truth_table.contradiction(False, False)
        )

    def test_logical_conjunction(self):
        self.assertTrue(
            src.truth_table.logical_conjunction(True, True)
        )
        self.assertFalse(
            src.truth_table.logical_conjunction(True, False)
        )
        self.assertFalse(
            src.truth_table.logical_conjunction(False, True)
        )
        self.assertFalse(
            src.truth_table.logical_conjunction(False, False)
        )

    def test_project_second(self):
        self.assertTrue(
            src.truth_table.project_second(True, True)
        )
        self.assertFalse(
            src.truth_table.project_second(True, False)
        )
        self.assertTrue(
            src.truth_table.project_second(False, True)
        )
        self.assertFalse(
            src.truth_table.project_second(False, False)
        )

    def test_converse_non_implication(self):
        self.assertFalse(
            src.truth_table.converse_non_implication(True, True)
        )
        self.assertFalse(
            src.truth_table.converse_non_implication(True, False)
        )
        self.assertTrue(
            src.truth_table.converse_non_implication(False, True)
        )
        self.assertFalse(
            src.truth_table.converse_non_implication(False, False)
        )

    def test_negate_first(self):
        self.assertFalse(src.truth_table.negate_first(True, True))
        self.assertFalse(src.truth_table.negate_first(True, False))
        self.assertTrue(src.truth_table.negate_first(False, True))
        self.assertTrue(src.truth_table.negate_first(False, False))

    def test_logical_nand(self):
        self.assertFalse(src.truth_table.logical_nand(True, True))
        self.assertTrue(src.truth_table.logical_nand(True, False))
        self.assertTrue(src.truth_table.logical_nand(False, True))
        self.assertTrue(src.truth_table.logical_nand(False, False))

    def test_tautology(self):
        self.assertTrue(src.truth_table.tautology(True, True))
        self.assertTrue(src.truth_table.tautology(True, False))
        self.assertTrue(src.truth_table.tautology(False, True))
        self.assertTrue(src.truth_table.tautology(False, False))

    def test_logical_disjunction(self):
        self.assertTrue(
            src.truth_table.logical_disjunction(True, True)
        )
        self.assertTrue(
            src.truth_table.logical_disjunction(True, False)
        )
        self.assertTrue(
            src.truth_table.logical_disjunction(False, True)
        )
        self.assertFalse(
            src.truth_table.logical_disjunction(False, False)
        )

    def test_exclusive_disjunction(self):
        self.assertFalse(src.truth_table.exclusive_disjunction(True, True))
        self.assertTrue(src.truth_table.exclusive_disjunction(True, False))
        self.assertTrue(src.truth_table.exclusive_disjunction(False, True))
        self.assertFalse(src.truth_table.exclusive_disjunction(False, False))

    def test_material_non_implication(self):
        self.assertFalse(
            src.truth_table.material_non_implication(True, True)
        )
        self.assertTrue(
            src.truth_table.material_non_implication(True, False)
        )
        self.assertFalse(
            src.truth_table.material_non_implication(False, True)
        )
        self.assertFalse(
            src.truth_table.material_non_implication(False, False)
        )

    def test_project_first(self):
        self.assertTrue(src.truth_table.project_first(True, True))
        self.assertTrue(src.truth_table.project_first(True, False))
        self.assertFalse(src.truth_table.project_first(False, True))
        self.assertFalse(src.truth_table.project_first(False, False))

    def test_converse_implication(self):
        self.assertTrue(src.truth_table.converse_implication(True, True))
        self.assertTrue(src.truth_table.converse_implication(True, False))
        self.assertFalse(src.truth_table.converse_implication(False, True))
        self.assertTrue(src.truth_table.converse_implication(False, False))

    def test_negate_second(self):
        self.assertFalse(src.truth_table.negate_second(True, True))
        self.assertTrue(src.truth_table.negate_second(True, False))
        self.assertFalse(src.truth_table.negate_second(False, True))
        self.assertTrue(src.truth_table.negate_second(False, False))

    def test_logical_nor(self):
        self.assertFalse(src.truth_table.logical_nor(True, True))
        self.assertFalse(src.truth_table.logical_nor(True, False))
        self.assertFalse(src.truth_table.logical_nor(False, True))
        self.assertTrue(src.truth_table.logical_nor(False, False))

    def test_logical_equality(self):
        self.assertTrue(src.truth_table.logical_equality(True, True))
        self.assertFalse(src.truth_table.logical_equality(True, False))
        self.assertFalse(src.truth_table.logical_equality(False, True))
        self.assertTrue(src.truth_table.logical_equality(False, False))

    def test_material_implication(self):
        self.assertTrue(src.truth_table.material_implication(True, True))
        self.assertFalse(src.truth_table.material_implication(True, False))
        self.assertTrue(src.truth_table.material_implication(False, True))
        self.assertTrue(src.truth_table.material_implication(False, False))


# Exceptions seen
# AttributeError
# TypeError
# AssertionError
# SyntaxError

continue the project

Make sure you are in the pumping_python folder with pwd in the terminal
```
pwd
```
if the terminal shows anything other than
```
.../pumping_python
```
change directory to the pumping_python folder
Once in pumping_python, change directory to the project
```
cd truth_table
```
the terminal shows
```
.../pumping_python/truth_table
```

I run the tests with pytest-watcher

uv run pytest-watcher . --now

the terminal shows

rootdir: .../pumping_python/truth_table
configfile: pyproject.toml
collected 16 items

tests/test_binary.py ................                         [ 66%]
tests/test_nullary_unary.py ....                              [100%]

======================== 16 passed in G.HIs ========================

test_negate_second

RED: make it fail

I add a new test with the first case for another Binary Operation - when the first input is True and the second input is True, to test_truth_table.py

    def test_converse_implication(self):
        self.assertTrue(src.truth_table.converse_implication(True, True))
        self.assertTrue(src.truth_table.converse_implication(True, False))
        self.assertFalse(src.truth_table.converse_implication(False, True))
        self.assertTrue(src.truth_table.converse_implication(False, False))

    def test_negate_second(self):
        self.assertFalse(src.truth_table.negate_second(True, True))


# Exceptions seen

the terminal shows AttributeError

AttributeError: module 'src.truth_table' has no attribute 'negate_second'

GREEN: make it pass

I add a function for negate_second to truth_table.py

def converse_implication(first_input, second_input):
    return first_input or not second_input


def negate_second(first_input, second_input):
    return False

the test passes. negate_second returns False, if the first input is True and the second input is True

REFACTOR: make it better

I add the next case - when the first input is True and the second input is False, to test_negate_second in test_truth_table.py

    def test_negate_second(self):
        self.assertFalse(src.truth_table.negate_second(True, True))
        self.assertTrue(src.truth_table.negate_second(True, False))

the terminal shows AssertionError

AssertionError: False is not true

I add an if statement to negate_second in truth_table.py
```
73def negate_second(first_input, second_input):
74    if first_input == True and second_input == False:
75        return True
76    return False
```
the test passes. negate_second returns
- True, if the first input is True and the second input is False
- False, if the first input is True and the second input is True
- the logical negation of the second input

I add the third case - when the first input is False and the second input is True, to test_negate_second in test_truth_table.py

    def test_negate_second(self):
        self.assertFalse(src.truth_table.negate_second(True, True))
        self.assertTrue(src.truth_table.negate_second(True, False))
        self.assertFalse(src.truth_table.negate_second(False, True))

the test is still green. negate_second returns

False, if the first input is False and the second input is True
the logical negation of the second input in all 3 cases

I add the last case - when the first input is False and the second input is False

    def test_negate_second(self):
        self.assertFalse(src.truth_table.negate_second(True, True))
        self.assertTrue(src.truth_table.negate_second(True, False))
        self.assertFalse(src.truth_table.negate_second(False, True))
        self.assertTrue(src.truth_table.negate_second(False, False))

the terminal shows AssertionError

AssertionError: False is not true

I add an if statement for the case to negate_second in truth_table.py

def negate_second(first_input, second_input):
    if first_input == False and second_input == False:
        return True
    if first_input == True and second_input == False:
        return True
    return False

the test passes. negate_second returns

True, if the first input is False and the second input is False
the logical negation of the second input in all 4 cases

I add a return statement to show that negate_second always returns the opposite of the second input

def negate_second(first_input, second_input):
    return not second_input
    if first_input == False and second_input == False:
        return True
    if first_input == True and second_input == False:
        return True
    return False

the test is still green

I remove the other statements in the function

def negate_second(first_input, second_input):
    return not second_input

Negate Second always returns

not second_input
the Logical Negation of the second input

It is the opposite (Logical Negation) of Project Second which always returns the second input

test_logical_nor

RED: make it fail

I add a test for logical_nor in test_truth_table.py

    def test_negate_second(self):
        self.assertFalse(src.truth_table.negate_second(True, True))
        self.assertTrue(src.truth_table.negate_second(True, False))
        self.assertFalse(src.truth_table.negate_second(False, True))
        self.assertTrue(src.truth_table.negate_second(False, False))

    def test_logical_nor(self):
        self.assertFalse(src.truth_table.logical_nor(True, True))


# Exceptions seen

the terminal shows AttributeError

AttributeError: module 'src.truth_table' has no attribute 'logical_nor'. Did you mean: 'logical_nand'?

GREEN: make it pass

I add the function to truth_table.py

def negate_second(first_input, second_input):
    return not second_input


def logical_nor(first_input, second_input):
    return False

the test passes. logical_nor returns False, if the first and second inputs are both True

REFACTOR: make it better

I add the second case - when the first input is True and the second input is False, to test_logical_nor in test_truth_table.py
```
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))
```
the test is still green. logical_nor returns
- False, if the first input is True and the second input is False
- False, if the first input is True and the second input is True
- False, if the first input is True

on to the next case - when the first input is False and the second input is True

    def test_logical_nor(self):
        self.assertFalse(src.truth_table.logical_nor(True, True))
        self.assertFalse(src.truth_table.logical_nor(True, False))
        self.assertFalse(src.truth_table.logical_nor(False, True))

the test is still green. logical_nor returns

False, if the first input is False and the second input is True
False, if the first input is True

I add the last case - when the first input is False and the second input is False

    def test_logical_nor(self):
        self.assertFalse(src.truth_table.logical_nor(True, True))
        self.assertFalse(src.truth_table.logical_nor(True, False))
        self.assertFalse(src.truth_table.logical_nor(False, True))
        self.assertTrue(src.truth_table.logical_nor(False, False))


# Exceptions seen

the terminal shows AssertionError

AssertionError: False is not true

I add an if statement for this case in truth_table.py
```
77def logical_nor(first_input, second_input):
78    if first_input == False and second_input == False:
79        return True
80    return False
```
the test passes. logical_nor returns
- True, if the first input is False and the second input is False
- False, if the first input is False and the second input is True
- False, if the first input is True

I make the if statement simpler

def logical_nor(first_input, second_input):
    # if first_input == False and second_input == False:
    if not first_input and not second_input:
        return True
    return False

the test is still green

since if something: return True is the same as return something, I use a conditional expression for the if statement in truth_table.py

def logical_nor(first_input, second_input):
    return not first_input and not second_input
    if not first_input and not second_input:
        return True
    return False

still green

I remove the other statements then factor out “not” because it happens 2 times

def logical_nor(first_input, second_input):
    return (not first_input) (not or) (not second_input)
    return not first_input and not second_input

the terminal shows SyntaxError

SyntaxError: invalid syntax

I add the correct statement

def logical_nor(first_input, second_input):
    # return (not first_input) (not or) (not second_input)
    return not (first_input or second_input)
    return not first_input and not second_input

green, green, green again 🎶

I remove the other statements in the function

def logical_nor(first_input, second_input):
    return not (first_input or second_input)

Logical NOR returns

not (first_input or second_input)
True if the first input is False and the second input is False
the Logical Negation of the Logical Disjunction (or) of the first input and second input
not or of the first input and second input

test_logical_equality

RED: make it fail

I add a new test for the next Binary Operation in test_truth_table.py

    def test_logical_nor(self):
        self.assertFalse(src.truth_table.logical_nor(True, True))
        self.assertFalse(src.truth_table.logical_nor(True, False))
        self.assertFalse(src.truth_table.logical_nor(False, True))
        self.assertTrue(src.truth_table.logical_nor(False, False))

    def test_logical_equality(self):
        self.assertTrue(src.truth_table.logical_equality(True, True))


# Exceptions seen

the terminal shows AttributeError

AttributeError: module 'src.truth_table' has no attribute 'logical_equality'. Did you mean: 'logical_identity'?

GREEN: make it pass

I add a function for it in truth_table.py

def logical_nor(first_input, second_input):
    return not (first_input or second_input)


def logical_equality(first_input, second_input):
    return True

the test passes. logical_equality returns True, if the first input is True and the second input is True

REFACTOR: make it better

I add the next case to test_logical_equality in test_truth_table.py

    def test_logical_equality(self):
        self.assertTrue(src.truth_table.logical_equality(True, True))
        self.assertFalse(src.truth_table.logical_equality(True, False))

the terminal shows AssertionError

AssertionError: True is not false

I add an if statement to logical_equality in truth_table.py
```
81def logical_equality(first_input, second_input):
82    if first_input and not second_input:
83        return False
84    return True
```
the test passes. logical_equality returns
- False, if the first input is True and the second input is False
- True, if the first input is True and the second input is True
- the second input, if the first input is True

I add the next case to test_logical_equality in test_truth_table.py

    def test_logical_equality(self):
        self.assertTrue(src.truth_table.logical_equality(True, True))
        self.assertFalse(src.truth_table.logical_equality(True, False))
        self.assertFalse(src.truth_table.logical_equality(False, True))

the terminal shows AssertionError

AssertionError: True is not false

I add another if statement to logical_equality in truth_table.py
```
81def logical_equality(first_input, second_input):
82    if not first_input and second_input:
83        return False
84    if first_input and not second_input:
85        return False
86    return True
```
the test passes. logical_equality returns
- False, if the first input is False and the second input is True
- False, if the first input is True and the second input is False
- True, if the first input is True and the second input is True
- the second input, if the first input is True
I add the last case to test_logical_equality in test_truth_table.py
```
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
146# Exceptions seen
```
the test is still green. logical_equality returns
- True, if the first input is False and the second input is False
- False, if the first input is False and the second input is True
- the logical_negation of the second input if the first input is False
- False, if the first input is True and the second input is False
- True, if the first input is True and the second input is True
- the second input, if the first input is True
- True, if the two inputs are the same
- False, if the two inputs are NOT the same

I use “or” to put the 2 statements that return False together, since they are at the same level in logical_equality in truth_table.py

def logical_equality(first_input, second_input):
    # if not first_input and second_input:
    #     return False
    # if first_input and not second_input:
    #     return False
    if (
        (not first_input and second_input)
        or
        (first_input and not second_input)
    ):
        return False
    return True

still green

since if something: return False is the same as return not (something), I remove the commented lines and use a conditional expression with not

def logical_equality(first_input, second_input):
    return not (
        (not first_input and second_input)
        or
        (first_input and not second_input)
    )
    if (
        (not first_input and second_input)
        or
        (first_input and not second_input)
    ):
        return False
    return True

greennn, yellow?

I remove the other statements in the function then “multiply not” by everything in the parentheses

def logical_equality(first_input, second_input):
    return (
        (not (not first_input and second_input))
        (not or)
        (not (first_input and not second_input))
    )
    return not (
        (not first_input and second_input)
        or
        (first_input and not second_input)
    )

the terminal shows SyntaxError

SyntaxError: invalid syntax

I change “not or” to “and”

def logical_equality(first_input, second_input):
    return (
        (not (not first_input and second_input))
        and
        (not (first_input and not second_input))
    )
    return not (
        (not first_input and second_input)
        or
        (first_input and not second_input)
    )

green again

I remove the other return statement then “multiply” “ not in the first parentheses

def logical_equality(first_input, second_input):
    return (
        # (not (not first_input and second_input))
        ((not not first_input) (not and) (not second_input))
        and
        (not (first_input and not second_input))
    )

the terminal shows SyntaxError

SyntaxError: invalid syntax

I change “not and” to “or”

def logical_equality(first_input, second_input):
    return (
        # (not (not first_input and second_input))
        ((not not first_input) or (not second_input))
        and
        (not (first_input and not second_input))
    )

the test is green again

I remove the commented line and “multiply” not in the next statement

def logical_equality(first_input, second_input):
    return (
        ((not not first_input) or (not second_input))
        and
        # (not (first_input and not second_input))
        ((not first_input) (not and) (not not second_input))
    )

the terminal shows SyntaxError

SyntaxError: invalid syntax

I change “not and” to “or”

def logical_equality(first_input, second_input):
    return (
        ((not not first_input) or (not second_input))
        and
        # (not (first_input and not second_input))
        ((not first_input) or (not not second_input))
    )

green again

I remove the commented line and not not from both parentheses because they cancel out

def logical_equality(first_input, second_input):
    return (
        (first_input or not second_input)
        and
        (not first_input or second_input)
    )

the test is still green

logical_equality returns True, if the first input and second input are the same, which means I can write a much simpler return statement thanks to the equality (==) symbol (2 equal signs together =+=)

def logical_equality(first_input, second_input):
    return first_input == second_input
    return (
        (first_input or not second_input)
        and
        (not first_input or second_input)
    )

the test is still green

Logical Equality returns

first_input == second_input
True when the first input is equal to the second input
the Logical Conjunction of the result of the Logical Disjunction of the first input and the Logical Negation of the second input, and the result of the Logical Disjunction of the Logical Negation of the first input, and the second input. Oh brother!
is the opposite of Exclusive Disjunction which returns True, only if the first input and second input are NOT equal

test_material_implication

RED: make it fail

I add a new test for one more Binary Operation in test_truth_table.py

    def test_logical_equality(self):
        self.assertTrue(src.truth_table.logical_equality(True, True))
        self.assertFalse(src.truth_table.logical_equality(True, False))
        self.assertFalse(src.truth_table.logical_equality(False, True))
        self.assertTrue(src.truth_table.logical_equality(False, False))

    def test_material_implication(self):
        self.assertTrue(src.truth_table.material_implication(True, True))


# Exceptions seen

the terminal shows AttributeError

AttributeError: module 'src.truth_table' has no attribute 'material_implication'

GREEN: make it pass

I add a function for material_implication in truth_table.py

def logical_equality(first_input, second_input):
    return first_input == second_input
    return (
        (first_input or not second_input)
        and
        (not first_input or second_input)
    )


def material_implication(first_input, second_input):
    return True

the test passes. material_implication returns True, if the first input is True and the second input is True

REFACTOR: make it better

I add the next case to test_material_implication in test_truth_table.py

    def test_material_implication(self):
        self.assertTrue(src.truth_table.material_implication(True, True))
        self.assertFalse(src.truth_table.material_implication(True, False))

the terminal shows AssertionError

AssertionError: True is not false

I add an if statement to material_implication in truth_table.py
```
90def material_implication(first_input, second_input):
91    if first_input and not second_input:
92        return False
93    return True
```
the test passes. material_implication returns
- False, if the first input is True and the second input is False
- True, if the first input is True and the second input is True
- the second input in these 2 cases
I add the next case to test_material_implication in test_truth_table.py
```
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))
```
the test is still green. material_implication returns
- True, if the first input is False and the second input is True
- False, if the first input is True and the second input is False
- True, if the first input is True and the second input is True
- returns the second input in all 3 cases

I add the fourth case

    def test_material_implication(self):
        self.assertTrue(src.truth_table.material_implication(True, True))
        self.assertFalse(src.truth_table.material_implication(True, False))
        self.assertTrue(src.truth_table.material_implication(False, True))
        self.assertTrue(src.truth_table.material_implication(False, False))


# Exceptions seen

the test is still green. material_implication returns

True, if the first input is False and the second input is False
True, if the first input is False and the second input is True
False, if the first input is True and the second input is False - this is the only case where it returns False
True, if the first input is True and the second input is True

since if something: return False is the same as return not (something), I add a return statement for the if statement in material_implication in truth_table.py

def material_implication(first_input, second_input):
    return not (first_input and not second_input)
    if first_input and not second_input:
        return False
    return True

the test is still green

I remove the other statements in the function then “multiply not” by the symbols in the parentheses

def material_implication(first_input, second_input):
    return (not first_input) (not and) (not not second_input)
    return not (first_input and not second_input)

the terminal shows SyntaxError

SyntaxError: invalid syntax

I change “not and” to “or”

def material_implication(first_input, second_input):
    return (not first_input) or (not not second_input)
    return not (first_input and not second_input)

the test is green again

I remove not not

def material_implication(first_input, second_input):
    return not first_input or second_input
    return (not first_input) or (not not second_input)

still green

I remove the other statement

def material_implication(first_input, second_input):
    return not first_input or second_input

Material Implication also known as Logical Implication returns

not first_input or second_input
the Logical Disjunction of the Logical Negation of the first input, and the second input
False only if the first input is True and the second input is False

it is the opposite (Logical Negation) of Material NonImplication which returns True only if the first input is True and the second input is False

more about Logical Equality

return ((first_input or not second_input) and (not first_input or second_input)) can be thought of as

return x or y

if x is first_input or not second_input
if y is not first_input or second_input

Exclusive Disjunction can also be thought of as

return (
    converse_implication(first_input, second_input)
    and
    material_implication(first_input, second_input)
)

because

converse_implication returns first_input or not second_input
material_implication return not first_input or second_input

This means that in the 4 cases

if the first input is True and the second input is True, logical_equality returns

(first_input or not second_input) and (not first_input or second_input)
(True        or not True        ) and (not True        or True        )
(True        or False           ) and (False           or True        )
 True                             and  True
 True                             # logical_conjunction(True, True)

if the first input is True and the second input is False, logical_equality returns

(first_input or not second_input) and (not first_input or second_input)
(True        or not False       ) and (not True        or False       )
(True        or True            ) and (False           or False       )
 True                             and  False
 False                            # logical_conjunction(True, False)

if the first input is False and the second input is True, logical_equality returns

(first_input or not second_input) and (not first_input or second_input)
(False       or not True        ) and (not False       or True        )
(False       or False           ) and (True            or True        )
 False                            and  True
 False                            # logical_conjunction(False, True)

if the first input is False and the second input is False, logical_equality returns

(first_input or not second_input) and (not first_input or second_input)
(False       or not False       ) and (not False       or False       )
(False       or True            ) and (True            or False       )
 True                             and  True
 True                             # logical_conjunction(True, True)

close the project

I close test_truth_table.py and truth_table.py in the editor
I click in the terminal, then use q on the keyboard to leave the tests. The terminal goes back to the command line
I change directory to the parent of truth_table
```
cd ..
```
the terminal shows
```
.../pumping_python
```
I am back in the pumping_python directory

review

Binary Operations take 2 inputs, each input can be True or False, if I name the first input first_input and the second one second_input, the tests show that

Material/Logical Implication
- returns not first_input or second_input
- returns False only if first_input is True and second_input is False
- is the opposite (Logical Negation) of Material NonImplication which returns True only if first_input is True and second_input is False
Logical Equality
- returns first_input == second_input
- returns True only if first_input and second_input are equal
- is the opposite (Logical Negation) of Exclusive Disjunction (Exclusive OR) which returns True only if first_input and second_input are NOT equal
Logical NOR
- returns not (first_input or second_input)
- returns True only if first_input is False and second_input is False
- is the opposite (Logical Negation) of Logical Disjunction which returns False only if first_input is False and second_input is False
Negate Second
- always returns not second_input
- returns True only if second_input is False
- is the opposite (Logical Negation) of Project Second which returns True only if second_input is True
Converse Implication
- returns first_input or not second_input
- returns False if first_input is False and second_input is True
- is the opposite (Logical Negation) of Converse NonImplication which returns True only if first_input is False and second_input is True
Project First
- always returns first_input
- returns True only if first_input is True
- is the opposite (Logical Negation) of Negate First which returns True only if first_input is False
Material NonImplication
- returns first_input and not second_input
- returns True only if first_input is True and second_input is False
- is the opposite (Logical Negation) of Material/Logical Implication which returns False only if first_input is True and second_input is False
Exclusive Disjunction
- returns first_input != second_input
- returns True only if first_input and second_input are NOT equal
- is the opposite (Logical Negation) of Logical Equality which returns True only if first_input and second_input are equal
Logical Disjunction
- returns first_input or second_input
- returns False only if first_input is False and second_input is False
- is the opposite (Logical Negation) of Logical NOR which returns True only if first_input is False and second_input is False
Tautology
- always returns True
- never returns False
- is the opposite (Logical Negation) of contradiction which always returns False
Logical NAND
- returns not (first_input and second_input)
- returns False only if first_input is True and second_input is True
- is the opposite (Logical Negation) (not) of Logical Conjunction (and) which returns True only if first_input is True and second_input is True
Negate First
- always returns not first_input
- returns True only if first_input is False
- is the opposite (Logical Negation) of Project First which returns True only if first_input is True
Converse NonImplication
- returns not first_input and second_input
- returns True only if first_input is False and second_input is True
- is the opposite (Logical Negation) of Converse Implication which returns False if first_input is False and second_input is True
Project Second
- always returns second_input
- returns True only if second_input is True
- is the opposite (Logical Negation) of Negate Second which returns True only if second_input is False
Logical Conjunction returns
- returns first_input and second_input
- returns True only if first_input is True and second_input is True
- is the opposite (Logical Negation) of Logical NAND which returns False only if first_input is True and second_input is True
Contradiction
- always returns False
- never returns True
- is the opposite (Logical Negation) of Tautology which always returns True

and

All the logic statements or conditions have been written with some or all of the above 3.

code from the chapter

Do you want to see all the CODE I typed for the Truth Table?

what is next?

Would you like to test the truth table tests?

rate pumping python

If this has been a 7 star experience for you, please CLICK HERE to leave a 5 star review of pumping python. It helps other people get into the book too

truth table: Binary Operations 3

truth table: test_truth_table_tests