truth table: Binary Operations 4

requirements

preview

These are the tests I have at the end of the chapter

import src.truth_table
import unittest


class TestBinaryOperations(unittest.TestCase):

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def test_material_implication(self):
        material_implication = (
            src.truth_table.material_implication
        )
        self.assertTrue(
            material_implication(True, True)
        )
        self.assertFalse(
            material_implication(True, False)
        )
        self.assertTrue(
            material_implication(False, True)
        )
        self.assertTrue(
            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 does not show
```
.../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 is my friend, and shows

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

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

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

Over the past 3 chapters I tested
- contradiction which always returns False
- logical_conjunction aka and which returns first_input and second_input
- project_second which always returns second_input
- converse_non_implication which returns not first_input and second_input
- negate_first which always returns not first_input
- logical_nand which returns not (first_input and second_input)
- tautology which always returns True
- logical_disjunction which returns first_input or second_input
- exclusive_disjunction which returns ((not first_input and second_input) or (first_input and not second_input))
- material_non_implication which returns first_input and not second_input
- project_first which always returns first_input
- converse_implication which returns first_input or not second_input

test_negate_second

The truth table for negate_second is

first input	second input	return
True	True	False
True	False	True
False	True	False
False	False	True

RED: make it fail

I add a new test for negate_second with an assertion for when the first input is True and the second input is True, to test_truth_table.py

first input	second input	return
True	True	False

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

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


# Exceptions seen

the terminal is my friend, and shows AttributeError

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

I do not have a definition for negate_second in truth_table.py

GREEN: make it pass

I add a function for negate_second to truth_table.py

def converse_implication(first_input, second_input):
    return logical_disjunction(
        first_input,
        logical_negation(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 an assertion for the next case, which is when the first input is True and the second input is False, to test_negate_second in test_truth_table.py

first input	second input	return
True	False	True

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


# Exceptions seen

the terminal is my friend, and shows AssertionError

AssertionError: False is not true

because the negate_second function returns False and the assertion expects True.

I add an if statement to negate_second in truth_table.py
```
102def negate_second(first_input, second_input):
103    if second_input == False:
104        return True
105    return False
```
the test passes because when negate_second is called, it runs if second_input == False:
- if second_input is NOT equal to False, it runs return False
- if second_input is equal to False, it runs return True

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

first input	second input	return
False	True	False

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


# Exceptions seen

the test is still green. negate_second returns the logical negation of the second input in all 3 cases.

I add an assertion for the last case, which is when the first input is False and the second input is False

first input	second input	return
False	False	True

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


# Exceptions seen

the test is still green.

I add the bool built-in function to the negate_second function in truth_table.py

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

still green.

I use Logical Negation (NOT) to write the statement in terms of True

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

green.

I remove == True

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

still green.

I remove bool

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

the test is still green, because when if second_input == False: runs, Python checks if second_input is equal to False. I can assume the following substitutions

if the value of something is False

if something           == False
if bool(something    ) == False
if bool(False        ) == False
if False               == False
if True                == True  # use equality
if True                         # remove '== True'
if not False                    # change to terms of False
if not something

if the value of something is True

if something           == False
if bool(something    ) == False
if bool(True         ) == False
if True                == False
if False               == True  # use equality
if False                        # remove '== True'
if not True                     # change to terms of True
if not something

if bool(something) == False is the same as if bool(not something) == True is the same as if bool(not something) is the same as if not something.

I add a conditional expression

def negate_second(first_input, second_input):
    # if second_input == False:
    # if bool(second_input) == False:
    # if bool(not second_input) == True:
    # if bool(not second_input):
    # if not second_input:
    #     return True
    # return False
    return True if not second_input else False

still green.

I remove True if and else False to make the statement simpler

def negate_second(first_input, second_input):
    # if second_input == False:
    # if bool(second_input) == False:
    # if bool(not second_input) == True:
    # if bool(not second_input):
    # if not second_input:
    #     return True
    # return False
    # return True if not second_input else False
    return not second_input

I remove the comments

def negate_second(first_input, second_input):
    return not second_input

I add a git commit message in another terminal
```
git commit -am 'add negate_second'
```

Negate Second always returns

not second_input
the Logical Negation of the second input

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

examples of Negate Second

returning a defective product, if the inputs are
- do I have the original receipt?
- does the product work?
receipt?

product works?

return?

yes

yes

no

yes

no

yes

no

yes

no

no

no

yes
I do not pick up calls from numbers that are not in my contact list, if the inputs are
- am I busy?
- is the number saved in my phone?
busy?

number saved?

send to voicemail?

yes

yes

no

yes

no

yes

no

yes

no

no

no

yes

test_logical_nor

The truth table for logical_nor is

first input	second input	return
True	True	False
True	False	False
False	True	False
False	False	True

RED: make it fail

I go back to the terminal where the tests are running

I add a test for logical_nor with an assertion for when the first input is True and the second input is True, to test_truth_table.py

first input	second input	return
True	True	False

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

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


# Exceptions seen

the terminal is my friend, and shows AttributeError

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

truth_table.py does not have any definition for logical_nor.

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 input is True and the second input is True.

REFACTOR: make it better

I add an assertion for the second case, which is when the first input is True and the second input is False, to test_logical_nor in test_truth_table.py

first input

second input

return

True

False

False
```
147    def test_logical_nor(self):
148        logical_nor = src.truth_table.logical_nor
149        self.assertFalse(logical_nor(True, True))
150        self.assertFalse(logical_nor(True, False))
151
152
153# Exceptions seen
```
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

I add an assertion for the next case, which is when the first input is False and the second input is True

first input	second input	return
False	True	False

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


# Exceptions seen

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 an assertion for the last case, which is when the first input is False and the second input is False

first input	second input	return
False	False	True

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


# Exceptions seen

the terminal is my friend, and shows AssertionError

AssertionError: False is not true

because the logical_nor function returns False and the assertion expects True.

I add if statements for this case to logical_nor in truth_table.py

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

the test passes.

I add the bool built-in function

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

the test still green.

I use Logical Negation (NOT) to write the if statements in terms of True

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

still green.

I remove == True

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

green.

I remove bool

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

still green, because I can assume the following substitutions for when if something == False: runs

if the value of something is False

if something           == False
if bool(something    ) == False
if bool(False        ) == False
if False               == False
if True                == True  # use equality
if True                         # remove '== True'
if not False                    # change to terms of False
if not something

if the value of something is True

if something           == False
if bool(something    ) == False
if bool(True         ) == False
if True                == False
if False               == True  # use equality
if False                        # remove '== True'
if not True                     # change to terms of True
if not something

if bool(something) == False is the same as if bool(not something) == True is the same as if bool(not something) is the same as if not something.

I use Logical Conjunction (AND) to put the two if statements together

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

still green, because I can put two if statements together when one is indented under the other

if something:
    if something_else:

can also be written as

if something and something_else:

I add a conditional expression

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

the test is still green.

I remove True if and else False

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

still green.

I write the statement in terms of not because it happens 2 times

    return (
        # True if
        # not first_input and not second_input
        (not first_input)
        (not or)
        (not second_input)
        # else False
    )

the terminal is my friend, and shows SyntaxError

SyntaxError: invalid syntax

because I cannot negate or this way

I “factor” out the nots

    return (
        # True if
        # not first_input and not second_input
        # (not first_input)
        # (not or)
        # (not second_input)
        not (first_input or second_input)
        # else False
    )

the test is green again.

logical_nor returns not (first_input or second_input) which is the Logical Negation (NOT) of the Logical Disjunction (OR) of the first input and the second input

logical_negation(
    logical_disjunction(
        first_input, second_input
    )
)

this means that in the four cases

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

not (first_input or second_input)
not (True        or True        )
not (True                       )
False # not logical_disjunction(True, False)

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

not (first_input or second_input)
not (True        or False       )
not (True                       )
False # not logical_disjunction(True, True)

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

not (first_input or second_input)
not (False       or True        )
not (True                       )
False # not logical_disjunction(False, False)

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

not (first_input or second_input)
not (False       or False       )
not (False                      )
True  # not logical_disjunction(False, True)

first	second	first or second	not (first or second)
True	True	True	False
True	False	True	False
False	True	True	False
False	False	False	True

I add a return statement to show this

def logical_nor(first_input, second_input):
    # if first_input == False:
    # if bool(first_input) == False:
    # if bool(not first_input) == True:
    # if bool(not first_input):
    # if not first_input:
        # if second_input == False:
        # if bool(second_input) == False:
        # if bool(not second_input) == True:
        # if bool(not second_input):
        # if not second_input:
    # if not first_input and not second_input:
    #         return True
    # return False
    return logical_negation(
        logical_disjunction(
            first_input, second_input
        )
    )
    return (
        # True if
        # not first_input and not second_input
        # (not first_input)
        # (not or)
        # (not second_input)
        not (first_input or second_input)
        # else False
    )

still green.

I remove the comments

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

I add a git commit message in the other terminal
```
git commit -am 'add logical_nor'
```
I can use either of these `return statements`_. The first return statement is the only one that runs in this case, because the return statement is the last thing to run in a function.

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

examples of Logical Nor

fitness discipline, if the inputs are
- did I eat cake?
- did I skip the workout?
eat cake

skip workout

disciplined

yes

yes

no

yes

no

no

no

yes

no

no

no

yes
a late fee, if the inputs are
- did I make the payment?
- am I within the grace period?
made payment

grace period

late fee charged

yes

yes

no

yes

no

no

no

yes

no

no

no

yes

test_logical_equality

The truth table for logical_equality is

first input	second input	return
True	True	True
True	False	False
False	True	False
False	False	True

RED: make it fail

I go back to the terminal where the tests are running

I add a test for Logical Equality with an assertion for when the first input is True and the second input is True to test_truth_table.py

first input	second input	return
True	True	True

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

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


# Exceptions seen

the terminal is my friend, and shows AttributeError

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

because there is no definition for logical_equality in truth_table.py

GREEN: make it pass

I add a function for it in truth_table.py

def logical_nor(first_input, second_input):
    return logical_negation(
        logical_disjunction(
            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 an assertion for the next case, which is when the first input is True and the second input is False, to test_logical_equality in test_truth_table.py

first input	second input	return
True	False	False

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


# Exceptions seen

the terminal is my friend, and shows AssertionError

AssertionError: True is not false

because the logical_equality function returns True and the assertion expects False.

I add an if statement to logical_equality in truth_table.py
```
115def logical_equality(first_input, second_input):
116    if second_input == False:
117        return False
118    return True
```
the test passes because when logical_equality is called, it runs if second_input == False:
- if second_input is NOT equal to False, it leaves the if statement then runs return True
- if second_input is equal to False, it runs return False
I add an assertion for the next case, which is when the first input is False and the second input is True, to test_logical_equality in test_truth_table.py

first input

second input

return

False

True

False
```
149    def test_logical_equality(self):
150        logical_equality = (
151            src.truth_table.logical_equality
152        )
153        self.assertTrue(logical_equality(True, True))
154        self.assertFalse(logical_equality(True, False))
155        self.assertFalse(logical_equality(False, True))
156
157
158# Exceptions seen
```
the terminal is my friend, and shows AssertionError
```
AssertionError: True is not false
```
because when logical_equality is called, it runs if second_input == False:
- if second_input is equal to False, it runs return False
- if second_input is NOT equal to False, it leaves the if statement then runs return True
- second_input is True in this case, which raises AssertionError since the assertion expects False and the function returns True
I add another if statement to the logical_equality function in truth_table.py
```
115def logical_equality(first_input, second_input):
116    if first_input == False:
117        return False
118    if second_input == False:
119        return False
120    return True
```
the test passes because when logical_equality is called, it runs if first_input == False:
- if first_input is NOT equal to False, it runs the next if statement - if second_input == False:
  - if second_input is NOT equal to False, it leaves the if statement then runs ``return True `` and leaves the function since the return statement is the last thing to run in a function
  - if second_input is equal to False, it runs return False and leaves the function since the return statement is the last thing to run in a function
- if first_input is equal to False, it runs return False and leaves the function since the return statement is the last thing to run in a function
I add an assertion for the last case, which is when the first input is False and the second input is False, to test_logical_equality in test_truth_table.py

first input

second input

return

False

False

True
```
149    def test_logical_equality(self):
150        logical_equality = (
151            src.truth_table.logical_equality
152        )
153        self.assertTrue(logical_equality(True, True))
154        self.assertFalse(logical_equality(True, False))
155        self.assertFalse(logical_equality(False, True))
156        self.assertTrue(logical_equality(False, False))
157
158
159# Exceptions seen
```
the terminal is my friend, and shows AssertionError
```
AssertionError: False is not true
```
because when logical_equality is called, it runs if first_input == False:
- if first_input is equal to False, it runs return False
- if first_input is NOT equal to False, it runs the next if statement - if second_input == False:
  - if second_input is NOT equal to False, it leaves the if statement then runs return True
  - if second_input is equal to False, it runs return False
  - second_input is False in this case, which raises AssertionError since the assertion expects True and the function returns False
I add an if statement to the logical_equality function in truth_table.py
```
115def logical_equality(first_input, second_input):
116    if first_input == False:
117        if second_input == False:
118            return True
119        return False
120    if second_input == False:
121        return False
122    return True
```
the test passes because when logical_equality is called, it runs if first_input == False:
- if first_input is NOT equal to False, it runs the next if statement - if second_input == False:
  - if second_input is NOT equal to False, it leaves the if statement then runs return True
  - if second_input is equal to False, it runs return False
- if first_input is equal to False, it runs if second_input == False:
  - if second_input is NOT equal to False, it leaves the if statement then runs the next line - return False
  - if second_input is equal to False, it runs return True

I add the bool built-in function

def logical_equality(first_input, second_input):
    # if first_input == False:
    if bool(first_input) == False:
        # if second_input == False:
        if bool(second_input) == False:
            return True
        return False
    # if second_input == False:
    if bool(second_input) == False:
        return False
    return True

the test is still green.

I use Logical Negation (NOT) to write the statements in terms of True

def logical_equality(first_input, second_input):
    # if first_input == False:
    # if bool(first_input) == False:
    if bool(not first_input) == True:
        # if second_input == False:
        # if bool(second_input) == False:
        if bool(not second_input) == True:
            return True
        return False
    # if second_input == False:
    # if bool(second_input) == False:
    if bool(not second_input) == True:
        return False
    return

still green.

I remove == True

def logical_equality(first_input, second_input):
    # if first_input == False:
    # if bool(first_input) == False:
    # if bool(not first_input) == True:
    if bool(not first_input):
        # if second_input == False:
        # if bool(second_input) == False:
        # if bool(not second_input) == True:
        if bool(not second_input):
            return True
        return False
    # if second_input == False:
    # if bool(second_input) == False:
    # if bool(not second_input) == True:
    if bool(not second_input):
        return False
    return True

green.

I remove bool

def logical_equality(first_input, second_input):
    # if first_input == False:
    # if bool(first_input) == False:
    # if bool(not first_input) == True:
    # if bool(not first_input):
    if not first_input:
        # if second_input == False:
        # if bool(second_input) == False:
        # if bool(not second_input) == True:
        # if bool(not second_input):
        if not second_input:
            return True
        return False
    # if second_input == False:
    # if bool(second_input) == False:
    # if bool(not second_input) == True:
    # if bool(not second_input):
    if not second_input:
        return False
    return True

still green because I can assume the following substitutions for when if something == False: runs

if the value of something is False

if something           == False
if bool(something    ) == False
if bool(False        ) == False
if False               == False
if True                == True  # use equality
if True                         # remove '== True'
if not False                    # change to terms of False
if not something

if the value of something is True

if something           == False
if bool(something    ) == False
if bool(True         ) == False
if True                == False
if False               == True  # use equality
if False                        # remove '== True'
if not True                     # change to terms of True
if not something

if bool(something) == False is the same as if bool(not something) == True is the same as if bool(not something) is the same as if not something.

I use Logical Conjunction (AND) to make two of the cases clearer

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

the test is still green, because I can put two if statements together when one is indented under the other

if something:
    if something_else:

can also be written as

if something and something_else:

I do the same thing for the other two cases

    if not first_input and not second_input:
        return True
    if not first_input and second_input:
        return False
    # if second_input == False:
    # if bool(second_input) == False:
    # if bool(not second_input) == True:
    # if bool(not second_input):
    # if not second_input:
    if first_input and not second_input:
        return False
    if first_input and second_input:
        return True

still green.

I put the if statements that return the same thing together

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

I use Logical Disjunction (OR) to put the two if statements that return True together

    # if not first_input and second_input:
    #     return False
    # if first_input and not second_input:
    #     return False
    # if first_input and second_input:
    #     return True
    # if not first_input and not second_input:
    #     return True
    if (
        (first_input and second_input)
        or
        (not first_input and not second_input)
    ):
        return True
    else:
        return False

green, because I can put two if statements together when they both return the same thing and are at the same indentation level

if something:
    return this
if something_else:
    return this

can also be written as

if something or something_else:
    return this

I add a conditional expression

    # if not first_input and second_input:
    #     return False
    # if first_input and not second_input:
    #     return False
    # if first_input and second_input:
    #     return True
    # if not first_input and not second_input:
    #     return True
    # if (
    #     (first_input and second_input)
    #     or
    #     (not first_input and not second_input)
    # ):
    #     return True
    # else:
    #     return False
    return True if (
        (first_input and second_input)
        or
        (not first_input and not second_input)
    ) else False

still green.

I remove True if and else False

    # return True if (
    return (
        (first_input and second_input)
        or
        (not first_input and not second_input)
    # ) else False
    )

the test is still green.

I write the second part of the statement in terms of not because it happens twice

    # return True if (
    return (
        (first_input and second_input)
        or
        # (not first_input and not second_input)
        (
            (not first_input)
            (not or)
            (not second_input)
        )
    # ) else False
    )

the terminal is my friend, and shows SyntaxError

SyntaxError: invalid syntax

because I cannot negate or this way

I “factor” out the nots

    # return True if (
    return (
        (first_input and second_input)
        or
        # (not first_input and not second_input)
        # (
        #     (not first_input)
        #     (not or)
        #     (not second_input)
        # )
        not (first_input or second_input)
    # ) else False
    )

the test is green again.

Logical Equality returns ((first_input and second_input) or not (first_input or second_input)), which can be thought of as the Logical Disjunction (OR) of the Logical Conjunction (AND) of the first input and second input, and the Logical Negation(NOT) of the Logical Disjunction (OR) of the first input and second input also known as the Logical NOR of the first input and second input

return logical_disjunction(
    logical_conjunction(first_input, second_input),
    logical_nor(first_input, second_input)
)

because

logical_disjunction(first_input, second_input)

first_input              == (first_input and second_input)
logical_conjunction      == (first_input and second_input)

second_input             == not (first_input or second_input)
logical_nor              == not (first_input or second_input)

logical_disjunction returns first_input or second_input
logical_conjunction returns first_input and second_input
logical_nor returns not (first_input or second_input)

or

return logical_disjunction(
    logical_conjunction(first_input, second_input),
    logical_negation(
        logical_disjunction(first_input, second_input)
    )
)

This means that in the four cases

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

(first and second) or (not (first or second))
(True  and True  ) or (not (True  or True  ))
 True              or (not  True            )
 True              or  False
 True              # logical_disjunction(True, False)

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

(first and second) or (not (first or second))
(True  and False ) or (not (True  or False ))
 False             or (not  True            )
 False             or  False
 False             # logical_disjunction(False, False)

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

(first and second) or (not (first or second))
(False and True  ) or (not (False or True  ))
 False             or (not  True            )
 False             or  False
 False             # logical_disjunction(False, False)

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

(first and second) or (not (first or second))
(False and False ) or (not (False or False ))
 False             or (not  False           )
 False             or  True
 True              # logical_disjunction(False, True)

first	second	first and second	first or second	not (first or second)	((first and second) or not (first or second))
True	True	True	False	True	True
True	False	False	True	True	False
False	True	False	False	False	False
False	False	False	True	True	True

I add a return statement to show this

    # return True if (
    return logical_disjunction(
        logical_conjunction(first_input, second_input),
        logical_nor(first_input, second_input)
    )
    return (
        (first_input and second_input)
        or
        # (not first_input and not second_input)
        # (
        #     (not first_input)
        #     (not or)
        #     (not second_input)
        # )
        not (first_input or second_input)
    # ) else False
    )

still green.

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

def logical_equality(first_input, second_input):
    # if first_input == False:
    # if bool(first_input) == False:
    # if bool(not first_input) == True:
    # if bool(not first_input):
    # if not first_input:
        # if second_input == False:
        # if bool(second_input) == False:
        # if bool(not second_input) == True:
        # if bool(not second_input):
        # if not second_input:
    # if second_input == False:
    # if bool(second_input) == False:
    # if bool(not second_input) == True:
    # if bool(not second_input):
    # if not second_input:
    # if not first_input and second_input:
    #     return False
    # if first_input and not second_input:
    #     return False
    # if first_input and second_input:
    #     return True
    # if not first_input and not second_input:
    #     return True
    # if (
    #     (first_input and second_input)
    #     or
    #     (not first_input and not second_input)
    # ):
    #     return True
    # else:
    #     return False
    # return True if (
    return first_input == second_input
    return logical_disjunction(
        logical_conjunction(first_input, second_input),
        logical_nor(first_input, second_input)
    )
    return (
        (first_input and second_input)
        or
        # (not first_input and not second_input)
        # (
        #     (not first_input)
        #     (not or)
        #     (not second_input)
        # )
        not (first_input or second_input)
    # ) else False
    )

the test is still green.

I remove the commented lines

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

I can use any of these `return statements`_. The first return statement is the only one that runs in this case, because the return statement is the last thing to run in a function.

I add a git commit message in the other terminal
```
git commit -am 'add logical_equality'
```

Logical Equality

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

examples of Logical Equality

my expectation matches reality, if the inputs are
- reality
- expectation
reality

my expectation

expectation matches reality

yes

yes

yes

yes

no

no

no

yes

no

no

no

yes
a market is balanced, if the inputs are
- supply
- demand
supply

demand

balance

high

high

yes

high

low

no

low

high

no

low

low

yes
we are in agreement, if the inputs are
- what did I say?
- what did you say?
I said

You said

agreement

yes

yes

yes

yes

no

no

no

yes

no

no

no

yes

test_material_implication

The truth table for material_implication is

first input	second input	return
True	True	True
True	False	False
False	True	True
False	False	True

RED: make it fail

I go back to the terminal where the tests are running

I add a test for material_implication with an assertion for when the first input is True and the second input is True, to test_truth_table.py

first input	second input	return
True	True	True

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

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


# Exceptions seen

the terminal is my friend, and shows AttributeError

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

because there is no definition for material_implication in truth_table.py

GREEN: make it pass

I add a function for material_implication to truth_table.py

def logical_equality(first_input, second_input):
    return first_input == second_input
    return logical_disjunction(
        logical_conjunction(first_input, second_input),
        logical_nor(first_input, second_input)
    )
    return (
        (first_input and second_input)
        or
        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 an assertion to test_material_implication for the next case, which is when the first input is True and the second input is False, in test_truth_table.py

first input	second input	return
True	False	False

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


# Exceptions seen

the terminal is my friend, and shows AssertionError

AssertionError: True is not false

because the function returns True and the assertion expects False.

I add an if statement to material_implication in truth_table.py
```
128def material_implication(first_input, second_input):
129    if second_input == False:
130        return False
131    return True
```
the test passes because when material_implication is called, it runs if second_input == False:
- if second_input is NOT equal to False, it runs return True
- if second_input is equal to False, it runs return False

I add an assertion to test_material_implication for the next case, which is when the first input is False and the second input is True in test_truth_table.py

first input	second input	return
False	True	True

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


# Exceptions seen

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
the second input in these three cases

I add an assertion for the fourth case, which is when the first input is False and the second input is False

first input	second input	return
False	False	True

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


# Exceptions seen

the terminal is my friend, and shows AssertionError

AssertionError: False is not true

because when material_implication gets called, it runs if second_input == False:

if second_input is NOT equal to False, it runs return True
if second_input is equal to False, it runs return False
second_input is False in this case, which causes AssertionError since the assertion expects True and the function returns False

I add an if statement to the material_implication function for the one case where it returns False, in truth_table.py

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

the test passes.

I use the bool built-in function

def material_implication(first_input, second_input):
    # if first_input == True:
    if bool(first_input) == True:
        # if second_input == False:
        if bool(second_input) == False:
            return False
    return True

the test is still green.

I use Logical Negation (NOT) to write the second if statement in terms of True

def material_implication(first_input, second_input):
    # if first_input == True:
    if bool(first_input) == True:
        # if second_input == False:
        # if bool(second_input) == False:
        if bool(not second_input) == True:
            return False
    return True

still green.

I remove == True

def material_implication(first_input, second_input):
    # if first_input == True:
    # if bool(first_input) == True:
    if bool(first_input):
        # if second_input == False:
        # if bool(second_input) == False:
        # if bool(not second_input) == True:
        if bool(not second_input):
            return False
    return True

green.

I remove bool

def material_implication(first_input, second_input):
    # if first_input == True:
    # if bool(first_input) == True:
    # if bool(first_input):
    if first_input:
        # if second_input == False:
        # if bool(second_input) == False:
        # if bool(not second_input) == True:
        # if bool(not second_input):
        if not second_input:
            return False
    return True

still green, because

when if something == False: runs, Python checks if something is equal to False. I can assume the following substitutions

if the value of something is False

if something           == False
if bool(something    ) == False
if bool(False        ) == False
if False               == False
if True                == True  # use equality
if True                         # remove '== True'
if not False                    # change to terms of False
if not something

if the value of something is True

if something           == False
if bool(something    ) == False
if bool(True         ) == False
if True                == False
if False               == True  # use equality
if False                        # remove '== True'
if not True                     # change to terms of True
if not something

when if something == True: runs, Python checks if (something) is equal to True. I can assume the following substitutions

if the value of something is False

if something           == True
if bool(something    ) == True
if bool(False        ) == True
if False               == True
if not True            == True  # change to terms of True
if not True                     # remove '==True'
if False
if something

if the value of something is True

if something           == True
if bool(something    ) == True
if bool(True         ) == True
if True                == True  # remove '==True'
if True
if something

if bool(something) == False is the same as if bool(not something) == True is the same as if bool(not something) is the same as if not something.
if bool(something) == True is the same as if bool(something) is the same as if something.

I use Logical Conjunction (AND) to put the two if statements together

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

the test is still green, because I can put two if statements together when one is indented under the other

if something:
    if something_else:

can also be written as

if something and something_else:

I add an else clause to make it clearer

def material_implication(first_input, second_input):
    # if first_input == True:
    # if bool(first_input) == True:
    # if bool(first_input):
    # if first_input:
        # if second_input == False:
        # if bool(second_input) == False:
        # if bool(not second_input) == True:
        # if bool(not second_input):
        # if not second_input:
    if first_input and not second_input:
        return False
    else:
        return True

still green.

I change the else clause to the Logical Negation (NOT) of the if statement

    if first_input and not second_input:
        return False
    # else:
    if not (first_input and not second_input):
        return True

green.

I add a conditional expression

    # if first_input and not second_input:
    #     return False
    # else:
    # if not (first_input and not second_input):
    #     return
    return (
        True if
        not (first_input and not second_input)
        else False
    )

still green.

I remove True if and else False to make it simpler

    # if first_input and not second_input:
    #     return False
    # else:
    # if not (first_input and not second_input):
    #     return
    return (
        # True if
        not (first_input and not second_input)
        # else False
    )

the test is still green.

I “multiply” not by the symbols in parentheses

    # if first_input and not second_input:
    #     return False
    # else:
    # if not (first_input and not second_input):
    #     return
    return (
        # True if
        # not (first_input and not second_input)
        (not first_input)
        (not and)
        (not not second_input)
        # else False
    )

the terminal is my friend, and shows SyntaxError

SyntaxError: invalid syntax

because I cannot negate and this way.

I change not and to or

    # if first_input and not second_input:
    #     return False
    # else:
    # if not (first_input and not second_input):
    #     return
    return (
        # True if
        # not (first_input and not second_input)
        (not first_input)
        # (not and)
        or
        (not not second_input)
        # else False
    )

the test is green again.

I remove not not because they cancel out

    # if first_input and not second_input:
    #     return False
    # else:
    # if not (first_input and not second_input):
    #     return
    return (
        # True if
        # not (first_input and not second_input)
        (not first_input)
        # (not and)
        or
        # (not not second_input)
        second_input
        # else False
    )

the test is still green, because two nots make a “right”?

material_implication returns not first_input or second_input

not first_input is the Logical Negation (NOT) of first_input
- if the first input is True, this part of the statement is False
- if the first input is False, this part of the statement is True
not first_input or second_input is the Logical Disjunction (OR) of the Logical Negation (NOT) of the first input, and the second input
```
logical_disjunction(
    logical_negation(first_input),
    second_input
)
```

this means that in the four cases

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

not first_input or second_input
not True        or True
False           or True
True            # logical_disjunction(False, True)

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

not first_input or second_input
not True        or False
False           or False
False           # logical_disjunction(False, False)

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

not first_input or second_input
not False       or True
True            or True
True            # logical_disjunction(True, True)

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

not first_input or second_input
not False       or False
True            or False
True            # logical_disjunction(True, False)

first	not first	second	(not first or second)
True	False	True	True
True	False	False	False
False	True	True	True
False	True	False	True

I add a return statement to show this

def material_implication(first_input, second_input):
    # if first_input == True:
    # if bool(first_input) == True:
    # if bool(first_input):
    # if first_input:
        # if second_input == False:
        # if bool(second_input) == False:
        # if bool(not second_input) == True:
        # if bool(not second_input):
        # if not second_input:
    # if first_input and not second_input:
    #     return False
    # else:
    # if not (first_input and not second_input):
    #     return
    return logical_disjunction(
        logical_negation(first_input),
        second_input
    )
    return (
        # True if
        # not (first_input and not second_input)
        (not first_input)
        # (not and)
        or
        # (not not second_input)
        second_input
        # else False
    )

still green.

I remove the comments

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

I can use either of these `return statements`_. The first return statement is the only one that runs in this case, because the return statement is the last thing to run in a function.

I add a git commit message in another terminal

git commit -am 'add material_implication'

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 Logical Negation (NOT) of Material Non-Implication which returns True only if the first input is True and the second input is False.

examples of Material Implication

does the fire alarm work, if the inputs are
- is there a fire?
- is the alarm ringing?
fire?

alarm?

alarm works

yes

yes

yes

yes

no

no

no

yes

yes (false positive)

no

no

yes

close the project

I close test_truth_table.py and truth_table.py
I click in the terminal where the tests are running
I 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 two inputs, each input can be True or False. If I name the first input first_input and the second input 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 Logical Negation (NOT) of Material Non-Implication which returns True only if first_input is True and second_input is False
first input

second input

return

True

True

True

True

False

False

False

True

True

False

False

True
Logical Equality
- returns first_input == second_input
- returns True only if first_input and second_input are equal
- is the Logical Negation (NOT) of Exclusive Disjunction (Exclusive OR) which returns True only if first_input and second_input are NOT equal
first input

second input

return

True

True

True

True

False

False

False

True

False

False

False

True
Logical NOR
- returns not (first_input or second_input)
- returns True only if first_input is False and second_input is False
- is the Logical Negation (NOT) of Logical Disjunction which returns False only if first_input is False and second_input is False
first input

second input

return

True

True

False

True

False

False

False

True

False

False

False

True
Negate Second
- always returns not second_input
- returns True only if second_input is False
- is the Logical Negation (NOT) of Project Second which returns True only if second_input is True
first input

second input

return

True

True

False

True

False

True

False

True

False

False

False

True
Converse Implication
- returns first_input or not second_input
- returns False if first_input is False and second_input is True
- is the Logical Negation (NOT) of Converse Non-Implication which returns True only if first_input is False and second_input is True
first input

second input

return

True

True

True

True

False

True

False

True

False

False

False

True
Project First
- always returns first_input
- returns True only if first_input is True
- is the Logical Negation (NOT) of Negate First which returns True only if first_input is False
first input

second input

return

True

True

True

True

False

True

False

True

False

False

False

False
Material Non-Implication
- returns first_input and not second_input
- returns True only if first_input is True and second_input is False
- is the Logical Negation (NOT) of Material/Logical Implication which returns False only if first_input is True and second_input is False
first input

second input

return

True

True

False

True

False

True

False

True

False

False

False

False
Exclusive Disjunction
- returns first_input != second_input
- returns True only if first_input and second_input are NOT equal
- is the Logical Negation (NOT) of Logical Equality which returns True only if first_input and second_input are equal
first input

second input

return

True

True

False

True

False

True

False

True

True

False

False

False
Logical Disjunction
- returns first_input or second_input
- returns False only if first_input is False and second_input is False
- is the Logical Negation (NOT) of Logical NOR which returns True only if first_input is False and second_input is False
first input

second input

return

True

True

True

True

False

True

False

True

True

False

False

False
Tautology
- always returns True
- never returns False
- is the Logical Negation (NOT) of contradiction which always returns False
first input

second input

return

True

True

True

True

False

True

False

True

True

False

False

True
Logical NAND
- returns not (first_input and second_input)
- returns False only if first_input is True and second_input is True
- is the Logical Negation (NOT) of Logical Conjunction (AND) which returns True only if first_input is True and second_input is True
first input

second input

return

True

True

False

True

False

True

False

True

True

False

False

True
Negate First
- always returns not first_input
- returns True only if first_input is False
- is the Logical Negation (NOT) of Project First which returns True only if first_input is True
first input

second input

return

True

True

False

True

False

False

False

True

True

False

False

True
Converse Non-Implication
- returns not first_input and second_input
- returns True only if first_input is False and second_input is True
- is the Logical Negation (NOT) of Converse Implication which returns False if first_input is False and second_input is True
first input

second input

return

True

True

False

True

False

False

False

True

True

False

False

False
Project Second
- always returns second_input
- returns True only if second_input is True
- is the Logical Negation (NOT) of Negate Second which returns True only if second_input is False
first input

second input

return

True

True

True

True

False

False

False

True

True

False

False

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 Logical Negation (NOT) of Logical NAND which returns False only if first_input is True and second_input is True
first input

second input

return

True

True

True

True

False

False

False

True

False

False

False

False
Contradiction
- always returns False
- never returns True
- is the Logical Negation (NOT) of Tautology which always returns True
first input

second input

return

True

True

False

True

False

False

False

True

False

False

False

False

and

The binary operations can be written with some combination of AND, NOT and OR.

return	True, True	True, False	False, True	False, False	operation
False	False	False	False	False	contradiction
first and second	True	False	False	False	logical_conjunction
second	True	False	True	False	project_second
(not first) and second	False	False	True	False	converse_non_implication
not first	False	False	True	True	negate_first
not (first and second)	False	True	True	True	logical_nand
True	True	True	True	True	tautology
first or second	True	True	True	False	logical_disjunction
(not (first and second)) and (first or second)	False	True	True	False	exclusive_disjunction
first and (not second)	False	True	False	False	material_non_implication
first	True	True	False	False	project_first
first or (not second)	True	True	False	True	converse_implication
not second	False	True	False	True	negate_second
not (first or second)	False	False	False	True	logical_nor
(not first or second) and (first or not second)	True	False	False	True	logical_equality
(not first) or second	True	False	True	True	material_implication

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 see more examples of the truth table?

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.

receipt?	product works?	return?
yes	yes	no
yes	no	yes
no	yes	no
no	no	yes

busy?	number saved?	send to voicemail?
yes	yes	no
yes	no	yes
no	yes	no
no	no	yes

eat cake	skip workout	disciplined
yes	yes	no
yes	no	no
no	yes	no
no	no	yes

made payment	grace period	late fee charged
yes	yes	no
yes	no	no
no	yes	no
no	no	yes