truth table: Binary Operations 4

requirements

preview

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

truth_table/tests/test_binary.py

import src.truth_table
import unittest


TT = True, True
TF = True, False
FT = False, True
FF = False, False


class TestBinaryOperations(unittest.TestCase):

    def test_contradiction(self):
        contradiction = src.truth_table.contradiction
        self.assertFalse(contradiction(*TT))
        self.assertFalse(contradiction(*TF))
        self.assertFalse(contradiction(*FT))
        self.assertFalse(contradiction(*FF))

    def test_logical_conjunction(self):
        logical_conjunction = (
            src.truth_table.logical_conjunction
        )
        self.assertTrue(logical_conjunction(*TT))
        self.assertFalse(logical_conjunction(*TF))
        self.assertFalse(logical_conjunction(*FT))
        self.assertFalse(logical_conjunction(*FF))

truth_table/tests/test_binary.py

    def test_project_second(self):
        project_second = src.truth_table.project_second
        self.assertTrue(project_second(*TT))
        self.assertFalse(project_second(*TF))
        self.assertTrue(project_second(*FT))
        self.assertFalse(project_second(*FF))

    def test_converse_non_implication(self):
        converse_non_implication = (
            src.truth_table.converse_non_implication
        )
        self.assertFalse(converse_non_implication(*TT))
        self.assertFalse(converse_non_implication(*TF))
        self.assertTrue(converse_non_implication(*FT))
        self.assertFalse(converse_non_implication(*FF))

truth_table/tests/test_binary.py

    def test_negate_first(self):
        negate_first = src.truth_table.negate_first
        self.assertFalse(negate_first(*TT))
        self.assertFalse(negate_first(*TF))
        self.assertTrue(negate_first(*FT))
        self.assertTrue(negate_first(*FF))

    def test_logical_nand(self):
        nand = src.truth_table.logical_nand
        self.assertFalse(nand(*TT))
        self.assertTrue(nand(*TF))
        self.assertTrue(nand(*FT))
        self.assertTrue(nand(*FF))

truth_table/tests/test_binary.py

    def test_tautology(self):
        tautology = src.truth_table.tautology
        self.assertTrue(tautology(*TT))
        self.assertTrue(tautology(*TF))
        self.assertTrue(tautology(*FT))
        self.assertTrue(tautology(*FF))

    def test_logical_disjunction(self):
        logical_disjunction = (
            src.truth_table.logical_disjunction
        )
        self.assertTrue(logical_disjunction(*TT))
        self.assertTrue(logical_disjunction(*TF))
        self.assertTrue(logical_disjunction(*FT))
        self.assertFalse(logical_disjunction(*FF))

truth_table/tests/test_binary.py

    def test_exclusive_disjunction(self):
        xor = src.truth_table.exclusive_disjunction
        self.assertFalse(xor(*TT))
        self.assertTrue(xor(*TF))
        self.assertTrue(xor(*FT))
        self.assertFalse(xor(*FF))

    def test_material_non_implication(self):
        material_non_implication = (
            src.truth_table.material_non_implication
        )
        self.assertFalse(material_non_implication(*TT))
        self.assertTrue(material_non_implication(*TF))
        self.assertFalse(material_non_implication(*FT))
        self.assertFalse(material_non_implication(*FF))

truth_table/tests/test_binary.py

    def test_project_first(self):
        project_first = src.truth_table.project_first
        self.assertTrue(project_first(*TT))
        self.assertTrue(project_first(*TF))
        self.assertFalse(project_first(*FT))
        self.assertFalse(project_first(*FF))

    def test_converse_implication(self):
        converse_implication = (
            src.truth_table.converse_implication
        )
        self.assertTrue(converse_implication(*TT))
        self.assertTrue(converse_implication(*TF))
        self.assertFalse(converse_implication(*FT))
        self.assertTrue(converse_implication(*FF))

truth_table/tests/test_binary.py

    def test_negate_second(self):
        negate_second = src.truth_table.negate_second
        self.assertFalse(negate_second(*TT))
        self.assertTrue(negate_second(*TF))
        self.assertFalse(negate_second(*FT))
        self.assertTrue(negate_second(*FF))

    def test_logical_nor(self):
        logical_nor = src.truth_table.logical_nor
        self.assertFalse(logical_nor(*TT))
        self.assertFalse(logical_nor(*TF))
        self.assertFalse(logical_nor(*FT))
        self.assertTrue(logical_nor(*FF))

truth_table/tests/test_binary.py

    def test_logical_equality(self):
        logical_equality = (
            src.truth_table.logical_equality
        )
        self.assertTrue(logical_equality(*TT))
        self.assertFalse(logical_equality(*TF))
        self.assertFalse(logical_equality(*FT))
        self.assertTrue(logical_equality(*FF))

    def test_material_implication(self):
        material_implication = (
            src.truth_table.material_implication
        )
        self.assertTrue(material_implication(*TT))
        self.assertFalse(material_implication(*TF))
        self.assertTrue(material_implication(*FT))
        self.assertTrue(material_implication(*FF))


# Exceptions seen
# AttributeError
# TypeError
# AssertionError
# SyntaxError

open the project

I make sure I am in the pumping_python folder with pwd in the terminal
```
pwd
```
if the terminal does not show
```
.../pumping_python
```
I change directory to the pumping_python folder
I change directory to the truth_table project
```
cd truth_table
```
the terminal shows
```
.../pumping_python/truth_table
```

I run the tests with pytest-watcher

uv run pytest-watcher . --now --patterns "**/*.py"

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 ===================

I open test_binary.py from the tests folder
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 if the first input is True and the second input is True, to tests/test_binary.py

first input	second input	return
True	True	False

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

GREEN: make it pass

I open __init__.py from the truth_table folder in the src folder

I add a function definition for negate_second to src/truth_table/__init__.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.

negate_second(True , True ) -> False

REFACTOR: make it better

I add an assertion for the next case, which is if the first input is True and the second input is False, to test_negate_second in tests/test_binary.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 src/truth_table/__init__.py

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

the test passes because Python checks if second_input == False: when negate_second is called

if second_input is NOT equal to False, it runs return False

negate_second(True , True ) -> False
└── def negate_second(first_input, second_input):
    ├── first_input  = True
    ├── second_input = True
    ├── if second_input == False:
    │       return True
    └── return False

if second_input is equal to False, it runs return True

negate_second(True , False) -> True
└── def negate_second(first_input, second_input):
    ├── first_input  = True
    ├── second_input = False
    └── if second_input == False:
        └── return True
        return False

negate_second(True , False) -> True
negate_second(True , True ) -> False

I add an assertion for the third case, which is if the first input is False and the second input is True, to test_negate_second in tests/test_binary.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.

negate_second(False, True ) -> False
negate_second(True , False) -> True
negate_second(True , True ) -> False

I add an assertion for the last case, which is if 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.

negate_second(False, False) -> True
negate_second(False, True ) -> False
negate_second(True , False) -> True
negate_second(True , True ) -> False

I add the bool built-in function to the negate_second function in src/truth_table/__init__.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 not bool(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 not bool(second_input) == True:
    if not bool(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 not bool(second_input) == True:
    # if not bool(second_input):
    if not second_input:
        return True
    return False

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

if the value of something is False

something = False

if something       == False
if bool(something) == False
if bool(False    ) == False # use the value
if False           == False # bool(False) returns False
if True            == True  # write in terms of True
if True                     # remove '== True'
if not False                # not False == True
if not something            # use the name for the value

if the value of something is True

something = True

if something       == False
if bool(something) == False
if bool(True     ) == False # use the value
if True            == False # bool(True) returns True
if False           == True  # write in terms of True
if not True        == True  # write in terms of True
if not True                 # remove '== True'
if not something            # use the name for the value

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

I add a conditional expression to negate_second

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

still green.

if not second_input vs return True
    return True     vs if not second_input
return False        vs else False

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

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

I remove the commented lines and other statements from negate_second

def negate_second(first_input, second_input):
    return not second_input

I add a git commit message in the other 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. It always negates 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 if the first input is True and the second input is True, to tests/test_binary.py

first input	second input	return
True	True	False

        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'?

src/truth_table/__init__.py does not have any definition for logical_nor.

GREEN: make it pass

I add logical_nor to src/truth_table/__init__.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.

logical_nor(True , True ) -> False

REFACTOR: make it better

I add an assertion for the second case, which is if the first input is True and the second input is False, to test_logical_nor in tests/test_binary.py

first input

second input

return

True

False

False
```
100    def test_logical_nor(self):
101        logical_nor = src.truth_table.logical_nor
102        self.assertFalse(logical_nor(True, True))
103        self.assertFalse(logical_nor(True, False))
104
105
106# 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
```
logical_nor(True , False) -> False
logical_nor(True , True ) -> False
```

I add an assertion for the next case, which is if 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

logical_nor(False, True ) -> False
logical_nor(True , False) -> False
logical_nor(True , True ) -> False

I add an assertion for the last case, which is if 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 src/truth_table/__init__.py

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

the test passes.

logical_nor(False, False) -> True
logical_nor(False, True ) -> False
logical_nor(True , False) -> False
logical_nor(True , True ) -> False

because Python checks if first_input is equal to False when the logical_nor function is called. When if first_input == False: runs,

if first_input is NOT equal to False, it leaves the if statement to run the rest of the function - return False

logical_nor(True , True ) -> False
└── def logical_nor(first_input, second_input):
    ├── first_input  = True
    ├── second_input = True
    ├── if first_input == False:
    │       if second_input == False:
    │           return True
    └── return False

logical_nor(True , False) -> False
└── def logical_nor(first_input, second_input):
    ├── first_input  = True
    ├── second_input = False
    ├── if first_input == False:
    │       if second_input == False:
    │           return True
    └── return False

if first_input is equal to False, it checks if second_input is equal to False

if second_input is NOT equal to False, it leaves if first_input == False: then runs return False

logical_nor(False, True ) -> False
└── def logical_nor(first_input, second_input):
    ├── first_input  = False
    ├── second_input = True
    ├── if first_input == False:
    │       if second_input == False:
    │           return True
    └── return False

if second_input is equal to False, it runs return True

logical_nor(False, False) -> True
└── def logical_nor(first_input, second_input):
    ├── first_input  = False
    ├── second_input = False
    └── if first_input == False:
        └── if second_input == False:
            └── return True
        return False

it only checks second_input if first_input is equal to False.

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 is 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 not bool(first_input) == True:
        # if second_input == False:
        # if bool(second_input) == False:
        if not bool(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 not bool(first_input) == True:
    if not bool(first_input):
        # if second_input == False:
        # if bool(second_input) == False:
        # if not bool(second_input) == True:
        if not bool(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 not bool(first_input) == True:
    # if not bool(first_input):
    if not first_input:
        # if second_input == False:
        # if bool(second_input) == False:
        # if not bool(second_input) == True:
        # if not bool(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

something = False

if something       == False
if bool(something) == False
if bool(False    ) == False # use the value
if False           == False # bool(False) returns False
if True            == True  # write in terms of True
if True                     # remove '== True'
if not False                # not False == True
if not something            # use the name for the value

if the value of something is True

something = True

if something       == False
if bool(something) == False
if bool(True     ) == False # use the value
if True            == False # bool(True) returns True
if False           == True  # write in terms of True
if not True        == True  # write in terms of True
if not True                 # remove '== True'
if not something            # use the name for the value

if bool(something) == False is the same as if not bool(something) == True is the same as if not bool(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 not bool(first_input) == True:
    # if not bool(first_input):
    # if not first_input:
        # if second_input == False:
        # if bool(second_input) == False:
        # if not bool(second_input) == True:
        # if not bool(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 to logical_nor

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

the test is still green.

I remove True if and else False

def logical_nor(first_input, second_input):
    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

def logical_nor(first_input, second_input):
    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, True)

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, False)

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, True)

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, False)

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):
    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.

logical_nor(False, False) -> True
└── not logical_disjunction(False, False) -> True

logical_nor(False, True ) -> False
└── not logical_disjunction(False, True ) -> False

logical_nor(True , False) -> False
└── not logical_disjunction(True , False) -> False

logical_nor(True , True ) -> False
└── not logical_disjunction(True , True ) -> False

I remove the commented lines and other statements from logical_nor

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.
the not of the or.

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 if the first input is True and the second input is True to tests/test_binary.py

first input	second input	return
True	True	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 src/truth_table/__init__.py.

GREEN: make it pass

I add a function definition for logical_equality in src/truth_table/__init__.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.

logical_equality(True , True ) -> True

REFACTOR: make it better

I add an assertion for the next case, which is if the first input is True and the second input is False, to test_logical_equality in tests/test_binary.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 src/truth_table/__init__.py
```
113def logical_equality(first_input, second_input):
114    if second_input == False:
115        return False
116    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.
```
logical_equality(True , False) -> False
logical_equality(True , True ) -> True
```
I add an assertion for the next case, which is if the first input is False and the second input is True, to test_logical_equality in tests/test_binary.py

first input

second input

return

False

True

False
```
115    def test_logical_equality(self):
116        logical_equality = (
117            src.truth_table.logical_equality
118        )
119        self.assertTrue(logical_equality(True, True))
120        self.assertFalse(logical_equality(True, False))
121        self.assertFalse(logical_equality(False, True))
122
123
124# Exceptions seen
```
the terminal is my friend, and shows AssertionError
```
AssertionError: True is not false
```
because when logical_equality is called, Python 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 src/truth_table/__init__.py
```
113def logical_equality(first_input, second_input):
114    if first_input == False:
115        return False
116    if second_input == False:
117        return False
118    return True
```
the test passes because when logical_equality is called, Python 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 then 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 then 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 then leaves the function since the return statement is the last thing to run in a function.
```
logical_equality(False, True ) -> False
logical_equality(True , False) -> False
logical_equality(True , True ) -> True
```
I add an assertion for the last case, which is if the first input is False and the second input is False, to test_logical_equality in tests/test_binary.py

first input

second input

return

False

False

True
```
115    def test_logical_equality(self):
116        logical_equality = (
117            src.truth_table.logical_equality
118        )
119        self.assertTrue(logical_equality(True, True))
120        self.assertFalse(logical_equality(True, False))
121        self.assertFalse(logical_equality(False, True))
122        self.assertTrue(logical_equality(False, False))
123
124
125# Exceptions seen
```
the terminal is my friend, and shows AssertionError
```
AssertionError: False is not true
```
because when logical_equality is called, Python 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 src/truth_table/__init__.py

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

the test passes.

logical_equality(False, False) -> True
logical_equality(False, True ) -> False
logical_equality(True , False) -> False
logical_equality(True , True ) -> True

Python checks if first_input == False: when logical_equality is called

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

logical_equality(True , True ) -> True
└── def logical_equality(first_input, second_input):
    ├── first_input  = True
    ├── second_input = True
    ├── if first_input == False:
    │       if second_input == False:
    │           return True
    │       return False
    ├── if second_input == False:
    │       return False
    └── return True

if second_input is equal to False, it runs return False

logical_equality(True , False) -> False
└── def logical_equality(first_input, second_input):
    ├── first_input  = True
    ├── second_input = False
    ├── if first_input == False:
    │       if second_input == False:
    │           return True
    │       return False
    └── if second_input == False:
        └── return False
        return True

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

logical_equality(False, True ) -> False
└── def logical_equality(first_input, second_input):
    ├── first_input  = False
    ├── second_input = True
    └── if first_input == False:
        ├── if second_input == False:
        │       return True
        └── return False
        if second_input == False:
            return False
        return True

if second_input is equal to False, it runs return True

logical_equality(False, False) -> True
└── def logical_equality(first_input, second_input):
    ├── first_input  = False
    ├── second_input = False
    └── if first_input == False:
        └── if second_input == False:
            └── return True
            return False
        if second_input == False:
            return False
        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 not bool(first_input) == True:
        # if second_input == False:
        # if bool(second_input) == False:
        if not bool(second_input) == True:
            return True
        return False
    # if second_input == False:
    # if bool(second_input) == False:
    if not bool(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 not bool(first_input) == True:
    if not bool(first_input):
        # if second_input == False:
        # if bool(second_input) == False:
        # if not bool(second_input) == True:
        if not bool(second_input):
            return True
        return False
    # if second_input == False:
    # if bool(second_input) == False:
    # if not bool(second_input) == True:
    if not bool(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 not bool(first_input) == True:
    # if not bool(first_input):
    if not first_input:
        # if second_input == False:
        # if bool(second_input) == False:
        # if not bool(second_input) == True:
        # if not bool(second_input):
        if not second_input:
            return True
        return False
    # if second_input == False:
    # if bool(second_input) == False:
    # if not bool(second_input) == True:
    # if not bool(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

something = False

if something       == False
if bool(something) == False
if bool(False    ) == False # use the value
if False           == False # bool(False) returns False
if True            == True  # write in terms of True
if True                     # remove '== True'
if not False                # not False == True
if not something            # use the name for the value

if the value of something is True

something = True

if something       == False
if bool(something) == False
if bool(True     ) == False # use the value
if True            == False # bool(True) returns True
if False           == True  # write in terms of True
if not True        == True  # write in terms of True
if not True                 # remove '== True'
if not something            # use the name for the value

if bool(something) == False is the same as if not bool(something) == True is the same as if not bool(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 not bool(first_input) == True:
    # if not bool(first_input):
    # if not first_input:
        # if second_input == False:
        # if bool(second_input) == False:
        # if not bool(second_input) == True:
        # if not bool(second_input):
        # if not second_input:
        #     return True
        # return False
    # if second_input == False:
    # if bool(second_input) == False:
    # if not bool(second_input) == True:
    # if not bool(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 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 second_input:
    if not first_input and not second_input:
        return True
    if not first_input and second_input:
        return False
    # 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

    # if not second_input:
    if not first_input and second_input:
        return False
    # if not second_input:
    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, then use an else clause for when logical_equality returns False

    # if not second_input:
    # if not first_input and second_input:
    #     return False
    # if not second_input:
    # 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 if 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 to logical_equality

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

still green.

I remove True if and else False

def logical_equality(first_input, second_input):
    return (
        # True if
        (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

def logical_equality(first_input, second_input):
    return (
        # True if
        (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

def logical_equality(first_input, second_input):
    return (
        # True if
        (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 returns first_input or second_input
logical_conjunction returns first_input and second_input
logical_nor returns not (first_input or second_input)

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)

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

def logical_equality(first_input, second_input):
    return logical_disjunction(
        logical_conjunction(first_input, second_input),
        logical_nor(first_input, second_input)
    )
    return (
        # True if
        (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 equal, which means I can write a much simpler return statement thanks to the equality (==) symbol (two equal signs together =+= on the keyboard)

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)
    )

the test is still green.

I remove the commented lines and other statements from logical_equality

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 if the first input is True and the second input is True, to tests/test_binary.py

first input	second input	return
True	True	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'.
                Did you mean: 'material_non_implication'?

because there is no definition for material_implication in src/truth_table/__init__.py.

GREEN: make it pass

I add a function for material_implication to src/truth_table/__init__.py

    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.

material_implication(True , True ) -> True

REFACTOR: make it better

I add an assertion to test_material_implication for the next case, which is if the first input is True and the second input is False, in tests/test_binary.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 src/truth_table/__init__.py
```
126def material_implication(first_input, second_input):
127    if second_input == False:
128        return False
129    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
```
material_implication(True , False) -> False
material_implication(True , True ) -> True
```

I add an assertion to test_material_implication for the next case, which is if the first input is False and the second input is True in tests/test_binary.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.

material_implication(False, True ) -> True
material_implication(True , False) -> False
material_implication(True , True ) -> True

I add an assertion for the fourth case, which is if 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 src/truth_table/__init__.py

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

the test passes.

material_implication(False, False) -> True
material_implication(False, True ) -> True
material_implication(True , False) -> False
material_implication(True , True ) -> True

Python checks if first_input == True: when material_implication is called

if first_input is NOT equal to True, it leaves the if statement to run the rest of the function - return True

material_implication(False, False) -> True
└── def material_implication(first_input, second_input):
    ├── first_input  = False
    ├── second_input = False
    ├── if first_input == True:
    │       if second_input == False:
    │           return False
    └── return True

material_implication(False, True ) -> True
└── def material_implication(first_input, second_input):
    ├── first_input  = False
    ├── second_input = True
    ├── if first_input == True:
    │       if second_input == False:
    │           return False
    └── return True

if first_input is equal to True, it checks if second_input is equal to False

if second_input is NOT equal to False, it leaves if first_input == True: to run the rest of the function - return True

material_implication(True , True ) -> True
└── def material_implication(first_input, second_input):
    ├── first_input  = True
    ├── second_input = True
    └── if first_input == True:
    ┌───┴── if second_input == False:
    │           return False
    └── return True

if second_input is equal to False it runs return False

material_implication(True , False) -> False
└── def material_implication(first_input, second_input):
    ├── first_input  = True
    ├── second_input = False
    └── if first_input == True:
        └── if second_input == False:
            └── return False
        return True

it only checks the second input if the first input is True.

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 not bool(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 not bool(second_input) == True:
        if not bool(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 not bool(second_input) == True:
        # if not bool(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

something = False

if something       == False
if bool(something) == False
if bool(False    ) == False # use the value
if False           == False # bool(False) returns False
if True            == True  # write in terms of True
if True                     # remove '== True'
if not False                # not False == True
if not something            # use the name for the value

if the value of something is True

something = True

if something       == False
if bool(something) == False
if bool(True     ) == False # use the value
if True            == False # bool(True) returns True
if False           == True  # write in terms of True
if not True        == True  # write in terms of True
if not True                 # remove '== True'
if not something            # use the name for the value

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

something = False

if something       == True
if bool(something) == True
if bool(False    ) == True  # use the value
if False           == True  # bool(False) returns False
if not True        == True  # write in terms of True
if not True                 # remove '== True'
if False                    # not True == False
if something                # use the name for the value

if the value of something is True

something = True

if something       == True
if bool(something) == True
if bool(True     ) == True # use the value
if True            == True # bool(True) returns True
if True                    # remove '== True'
if something               # use the name for the value

if bool(something) == False is the same as if not bool(something) == True is the same as if not bool(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 not bool(second_input) == True:
        # if not bool(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

    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 to material_implication

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

still green.

I remove True if and else False to make it simpler

def material_implication(first_input, second_input):
    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

def material_implication(first_input, second_input):
    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

def material_implication(first_input, second_input):
    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

def material_implication(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
    )

is the test 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):
    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.

material_implication(False, False) -> True
└── logical_disjunction(True , False) -> True

material_implication(False, True ) -> True
└── logical_disjunction(True , True ) -> True

material_implication(True , False) -> False
└── logical_disjunction(False, False) -> False

material_implication(True , True ) -> True
└── logical_disjunction(False, True ) -> True

I remove the commented lines and other statements from material_implication

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 the other 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

extract global variables for truth table cases

I go back to the terminal where the tests are running

I add variables for the four test cases that are repeated in every test, in tests/test_binary.py

import src.truth_table
import unittest


TT = True, True
TF = True, False
FT = False, True
FF = False, False


class TestBinaryOperations(unittest.TestCase):

    def test_contradiction(self):

I use the variables with a single starred expression to remove repetition of True, True, True, False, False, True and False, False from test_contradiction

    def test_contradiction(self):
        contradiction = src.truth_table.contradiction
        # self.assertFalse(contradiction(True, True))
        self.assertFalse(contradiction(*TT))
        # self.assertFalse(contradiction(True, True))
        self.assertFalse(contradiction(*TF))
        # self.assertFalse(contradiction(False, True))
        self.assertFalse(contradiction(*FT))
        # self.assertFalse(contradiction(False, False))
        self.assertFalse(contradiction(*FF))

    def test_logical_conjunction(self):

the test is still green.

I remove the commented lines from test_logical_conjunction

    def test_contradiction(self):
        contradiction = src.truth_table.contradiction
        self.assertFalse(contradiction(*TT))
        self.assertFalse(contradiction(*TF))
        self.assertFalse(contradiction(*FT))
        self.assertFalse(contradiction(*FF))

    def test_logical_conjunction(self):

I use the variables with a single starred expression to remove repetition of True, True, True, False, False, True and False, False from test_logical_conjunction

    def test_logical_conjunction(self):
        logical_conjunction = (
            src.truth_table.logical_conjunction
        )
        self.assertTrue(logical_conjunction(*TT))
        self.assertFalse(logical_conjunction(*TF))
        self.assertFalse(logical_conjunction(*FT))
        self.assertFalse(logical_conjunction(*FF))

    def test_project_second(self):

still green.

I use the variables with a single starred expression to remove repetition of True, True, True, False, False, True and False, False from test_project_second

    def test_project_second(self):
        project_second = src.truth_table.project_second
        self.assertTrue(project_second(*TT))
        self.assertFalse(project_second(*TF))
        self.assertTrue(project_second(*FT))
        self.assertFalse(project_second(*FF))

    def test_converse_non_implication(self):

green.

I use the variables with a single starred expression to remove repetition of True, True, True, False, False, True and False, False from test_converse_non_implication

    def test_converse_non_implication(self):
        converse_non_implication = (
            src.truth_table.converse_non_implication
        )
        self.assertFalse(converse_non_implication(*TT))
        self.assertFalse(converse_non_implication(*TF))
        self.assertTrue(converse_non_implication(*FT))
        self.assertFalse(converse_non_implication(*FF))

    def test_negate_first(self):

still green.

I use the variables with a single starred expression to remove repetition of True, True, True, False, False, True and False, False from test_negate_first

    def test_negate_first(self):
        negate_first = src.truth_table.negate_first
        self.assertFalse(negate_first(*TT))
        self.assertFalse(negate_first(*TF))
        self.assertTrue(negate_first(*FT))
        self.assertTrue(negate_first(*FF))

    def test_logical_nand(self):

the test is still green.

I use the variables with a single starred expression to remove repetition of True, True, True, False, False, True and False, False from test_logical_nand

    def test_logical_nand(self):
        nand = src.truth_table.logical_nand
        self.assertFalse(nand(*TT))
        self.assertTrue(nand(*TF))
        self.assertTrue(nand(*FT))
        self.assertTrue(nand(*FF))

    def test_tautology(self):

still green.

I use the variables with a single starred expression to remove repetition of True, True, True, False, False, True and False, False from test_tautology

    def test_tautology(self):
        tautology = src.truth_table.tautology
        self.assertTrue(tautology(*TT))
        self.assertTrue(tautology(*TF))
        self.assertTrue(tautology(*FT))
        self.assertTrue(tautology(*FF))

    def test_logical_disjunction(self):

green.

I use the variables with a single starred expression to remove repetition of True, True, True, False, False, True and False, False from test_logical_disjunction

    def test_logical_disjunction(self):
        logical_disjunction = (
            src.truth_table.logical_disjunction
        )
        self.assertTrue(logical_disjunction(*TT))
        self.assertTrue(logical_disjunction(*TF))
        self.assertTrue(logical_disjunction(*FT))
        self.assertFalse(logical_disjunction(*FF))

    def test_exclusive_disjunction(self):

still green.

I use the variables with a single starred expression to remove repetition of True, True, True, False, False, True and False, False from test_exclusive_disjunction

    def test_exclusive_disjunction(self):
        xor = src.truth_table.exclusive_disjunction
        self.assertFalse(xor(*TT))
        self.assertTrue(xor(*TF))
        self.assertTrue(xor(*FT))
        self.assertFalse(xor(*FF))

    def test_material_non_implication(self):

the test is still green.

I use the variables with a single starred expression to remove repetition of True, True, True, False, False, True and False, False from test_material_non_implication

    def test_material_non_implication(self):
        material_non_implication = (
            src.truth_table.material_non_implication
        )
        self.assertFalse(material_non_implication(*TT))
        self.assertTrue(material_non_implication(*TF))
        self.assertFalse(material_non_implication(*FT))
        self.assertFalse(material_non_implication(*FF))

    def test_project_first(self):

still green.

I use the variables with a single starred expression to remove repetition of True, True, True, False, False, True and False, False from test_project_first

    def test_project_first(self):
        project_first = src.truth_table.project_first
        self.assertTrue(project_first(*TT))
        self.assertTrue(project_first(*TF))
        self.assertFalse(project_first(*FT))
        self.assertFalse(project_first(*FF))

    def test_converse_implication(self):

green.

I use the variables with a single starred expression to remove repetition of True, True, True, False, False, True and False, False from test_converse_implication

    def test_converse_implication(self):
        converse_implication = (
            src.truth_table.converse_implication
        )
        self.assertTrue(converse_implication(*TT))
        self.assertTrue(converse_implication(*TF))
        self.assertFalse(converse_implication(*FT))
        self.assertTrue(converse_implication(*FF))

    def test_negate_second(self):

still green.

I use the variables with a single starred expression to remove repetition of True, True, True, False, False, True and False, False from test_negate_second

    def test_negate_second(self):
        negate_second = src.truth_table.negate_second
        self.assertFalse(negate_second(*TT))
        self.assertTrue(negate_second(*TF))
        self.assertFalse(negate_second(*FT))
        self.assertTrue(negate_second(*FF))

    def test_logical_nor(self):

the test is still green.

I use the variables with a single starred expression to remove repetition of True, True, True, False, False, True and False, False from test_logical_nor

    def test_logical_nor(self):
        logical_nor = src.truth_table.logical_nor
        self.assertFalse(logical_nor(*TT))
        self.assertFalse(logical_nor(*TF))
        self.assertFalse(logical_nor(*FT))
        self.assertTrue(logical_nor(*FF))

    def test_logical_equality(self):

still green.

I use the variables with a single starred expression to remove repetition of True, True, True, False, False, True and False, False from test_logical_equality

    def test_logical_equality(self):
        logical_equality = (
            src.truth_table.logical_equality
        )
        self.assertTrue(logical_equality(*TT))
        self.assertFalse(logical_equality(*TF))
        self.assertFalse(logical_equality(*FT))
        self.assertTrue(logical_equality(*FF))

    def test_material_implication(self):

green.

I use the variables with a single starred expression to remove repetition of True, True, True, False, False, True and False, False from test_material_implication

    def test_material_implication(self):
        material_implication = (
            src.truth_table.material_implication
        )
        self.assertTrue(material_implication(*TT))
        self.assertFalse(material_implication(*TF))
        self.assertTrue(material_implication(*FT))
        self.assertTrue(material_implication(*FF))


# Exceptions seen
# AttributeError
# TypeError
# AssertionError
# SyntaxError

still green.

I add a git commit message in the other terminal

git commit -am \
'extract global variables for truth table cases'

close the project

I close tests/test_binary.py and src/truth_table/__init__.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 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	name of 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