truth table: Binary Operations 2

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


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

truth_table/tests/test_binary.py

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

truth_table/tests/test_binary.py

    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):
        nand = src.truth_table.logical_nand
        self.assertFalse(nand(True, True))
        self.assertTrue(nand(True, False))
        self.assertTrue(nand(False, True))
        self.assertTrue(nand(False, False))

truth_table/tests/test_binary.py

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


# Exceptions seen
# AttributeError
# TypeError
# AssertionError
# SyntaxError

open 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
```

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 8 items

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

================== 8 passed in G.HIs ===================

I hold ctrl (Windows) or option (MacOS) on the keyboard, then click on tests/test_binary.py with the mouse to open it
So far I have 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

test_negate_first

The truth table for negate_first is

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

RED: make it fail

I add a test for negate_first with an assertion for if the first input is True and the second input is True, to test_binary.py

first input	second input	return
True	True	False

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


# Exceptions seen

the terminal is my friend, and shows AttributeError

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

there is no definition for negate_first in truth_table.py

GREEN: make it pass

I open truth_table/__init__.py from the src folder

I add negate_first to truth_table.py

def converse_non_implication(first_input, second_input):
    return logical_conjunction(
        logical_negation(first_input),
        second_input
    )
    return not first_input and second_input


def negate_first(first_input, second_input):
    return False

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

negate_first(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_negate_first in test_binary.py

first input

second input

return

True

False

False
```
39    def test_negate_first(self):
40        negate_first = src.truth_table.negate_first
41        self.assertFalse(negate_first(True, True))
42        self.assertFalse(negate_first(True, False))
43
44
45# Exceptions seen
```
the test is still green. negate_first 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.
```
negate_first(True , False) -> False
negate_first(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	True

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


# Exceptions seen

the terminal is my friend, and shows AssertionError

AssertionError: False is not true

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

I add an if statement for this case to negate_first in truth_table.py

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

the test passes. negate_first returns

True, if the first input is False
False, if the above condition is not met

negate_first(False, True ) -> True
negate_first(True , False) -> False
negate_first(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 to test_negate_first in test_binary.py

first input	second input	return
False	False	True

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


# Exceptions seen

the test is still green because Python checks if first_input is equal to False when if first_input == False: runs,

if first_input is NOT equal to False, it leaves the if statement and continues to run the rest of the function - return False then leaves the function since the return statement is the last thing to run in a function

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

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

if first_input is equal to False, it goes to the next line - return True then leaves the function since the return statement is the last thing to run in a function

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

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

I add the bool built-in function to the if statement in the negate_first function in truth_table.py

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

still green.

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

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

green.

I remove == True

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

still green.

I remove bool

def negate_first(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:
        return True
    return False

the test is still green because Python checks the value of not first_input when if not first_input: 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 add an else clause to be clearer

def negate_first(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:
        return True
    else:
        return False

still green.

I use a conditional expression (ternary operator) for the if statements

def negate_first(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:
    #     return True
    # else:
    #     return False
    return True if not first_input else False

still green.

if not first_input: vs return True
    return True     vs if not first_input
else:               vs else
    return False    vs False

I remove True if and else False

def negate_first(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:
    #     return True
    # else:
    #     return False
    # return True if not first_input else False
    return not first_input

green.

I remove the commented lines

def negate_first(first_input, second_input):
    return not first_input

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

Negate First always returns

not first_input
True, if the first input is False.
False, if the first input is True.
the Logical Negation (NOT) of the first input in all cases. It does not care about the second input, it negates the first input.

examples of Negate First

approval to do something based only on risk, if the inputs are
- is it risky?
- has a good reason?
is risky?

good reason?

approved

yes

yes

no

yes

no

no

no

yes

yes

no

no

yes
going for a walk, if the inputs are
- is it raining?
- do I feel like walking?
is raining?

feel like walking?

should walk

yes

yes

no

yes

no

no

no

yes

yes

no

no

yes
smoke detector battery test, if the inputs are
- is the battery dead?
- is there smoke?
battery dead?

is there smoke?

beep

yes

yes

no

yes

no

no

no

yes

yes

no

no

yes
can the system be used while it is being updated, if the inputs are
- is update running?
- is user admin?
update running?

admin?

system can be used

yes

yes

no

yes

no

no

no

yes

yes

no

no

yes

test_logical_nand

The truth table for logical_nand is

first input	second input	return
True	True	False
True	False	True
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 logical_nand with an assertion for if the first input is True and the second input is True, to test_binary.py

first input	second input	return
True	True	False

        self.assertTrue(negate_first(False, False))

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


# Exceptions seen

the terminal is my friend, and shows AttributeError

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

because there is no definition for logical_nand in truth_table.py

GREEN: make it pass

I add logical_nand to truth_table.py

def negate_first(first_input, second_input):
    return not first_input


def logical_nand(first_input, second_input):
    return False

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

logical_nand(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_nand in test_binary.py

first input

second input

return

True

False

True
```
46    def test_logical_nand(self):
47        nand = src.truth_table.logical_nand
48        self.assertFalse(nand(True, True))
49        self.assertTrue(nand(True, False))
50
51
52# Exceptions seen
```
the terminal is my friend, and shows AssertionError
```
AssertionError: False is not true
```
because the function returns False and the assertion expects True.

I add an if statement to the logical_nand function in truth_table.py

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

the test passes. logical_nand returns

True, if the second input is False
False, if the above condition is NOT met
the logical negation of the second input so far

logical_nand(True , False) -> True
logical_nand(True , True ) -> False

I add another assertion, for the case when the first input is False and the second input is True, to test_logical_nand in test_binary.py

first input

second input

return

False

True

True
```
46    def test_logical_nand(self):
47        nand = src.truth_table.logical_nand
48        self.assertFalse(nand(True, True))
49        self.assertTrue(nand(True, False))
50        self.assertTrue(nand(False, True))
51
52
53# Exceptions seen
```
the terminal is my friend, and shows AssertionError
```
AssertionError: False is not true
```
because Python checks if second_input is equal to False when if second_input == False: runs,
- if second_input is NOT equal to False, it leaves the if statement and continues to run the rest of the function - return False 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 goes to the next line - return True then leaves the function since the return statement is the last thing to run in a function
- second_input is True in this case, which raises AssertionError since the function returns False and the assertion expects True

I add an if statement to the logical_nand function in truth_table.py

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

the test passes. logical_nand returns

True, if the first input is False
True, if the second input is False
False, if none of the above conditions are met

logical_nand(False, True ) -> True
logical_nand(True , False) -> True
logical_nand(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, to test_logical_nand in test_binary.py

first input	second input	return
False	False	True

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


# Exceptions seen

the test is still green because when logical_nand is called it runs if first_input == False:, where Python checks if first_input is equal to False

if first_input is equal to False, it goes to the next line - return True then leaves the function since the return statement is the last thing to run in a function

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

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

if first_input is NOT equal to False, it leaves the if statement and continues to the next if statement in the function - if second_input == False: which checks if second_input is equal to False

if second_input is equal to False, it goes to the next line - return True then leaves the function since the return statement is the last thing to run in a function

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

if second_input is NOT equal to False, it leaves the if statement and continues to run the rest of the function - return False then leaves the function since the return statement is the last thing to run in a function

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

There is only one case where logical_nand returns False (the first case, when the first input is True and the second input is True). I add if statements for it, in truth_table.py

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

still green because logical_nand returns

False if the first input is True and the second input is True
True if the above condition is NOT met

logical_nand(False, False) -> True
logical_nand(False, True ) -> True
logical_nand(True , False) -> True
logical_nand(True , True ) -> False

Python checks if first_input is equal to True when if first_input == True: runs

if first_input is NOT equal to True, it leaves the if statement and continues to run the rest of the function - return True then leaves the function since the return statement is the last thing to run in a function

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

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

if first_input is equal to True, it goes to the next if statement - if second_input == True, which checks if second_input is equal to True

if second_input is NOT equal to True, it leaves the if statement and continues to run the rest of the function - return True then leaves the function since the return statement is the last thing to run in a function

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

if second_input is equal to True, it goes to the next line - return False then leaves the function since the return statement is the last thing to run in a function

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

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

I use the bool built-in function

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

green.

I remove == True

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

still green.

I remove bool

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

the test is still green, because I can assume the following substitutions for if something == True:

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) == 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 logical_nand(first_input, second_input):
    # if first_input == False:
    #     return True
    # if second_input == False:
    #     return True
    # return False
    # if first_input == True:
    # if bool(first_input) == True:
    # if bool(first_input):
    # if first_input:
        # if second_input == True:
        # if bool(second_input) == True:
        # if bool(second_input):
        # if second_input:
    if first_input and second_input:
            return False
    return True

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 logical_nand(first_input, second_input):
    # if first_input == False:
    #     return True
    # if second_input == False:
    #     return True
    # return False
    # if first_input == True:
    # if bool(first_input) == True:
    # if bool(first_input):
    # if first_input:
        # if second_input == True:
        # if bool(second_input) == True:
        # if bool(second_input):
        # if second_input:
    if first_input and second_input:
        return False
    else:
        return True

green.

I rewrite the else clause with the Logical Negation (NOT) of first_input and second_input so I can write the statements with a conditional expression (ternary operator)

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

still green.

I move the first if statement below this new one

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

the test is still green.

I change if first_input and second_input to an else clause

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

still green.

I add a conditional expression

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

green.

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

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

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

still green because when there is only one if statement that returns False with an else clause

if something:
    return False
else:
    return True

since else is the logical_negation (not) of the if statement

if something:
    return False
if not something:
    return True

I can use its logical negation (not) to return True

if not something:
    return True
else:
    return False

I can then write it with a ternary operator (conditional expression)

return True if not (something) else False

which can be made simpler as

return not (something)

this means if something: return False is the same as return not (something) since Python groups objects as False or True.

logical_nand returns not (first_input and second_input) which is the Logical Negation (NOT) of the Logical Conjunction (AND) of the first input and second input, which means that in the four cases

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

not (first and second)
not (True  and True  )  # not logical_conjunction(True, True)
not (True            )
False

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

not (first and second)
not (True  and False ) # not logical_conjunction(True, False)
not (False           )
True

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

not (first and second)
not (False and True  )  # not logical_conjunction(False, True)
not (False           )
True

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

not (first and second)
not (False and False ) # not logical_conjunction(False, False)
not (False           )
True

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

I add a return statement to show this

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

the test is still green.

logical_nand(False, False) -> True
 └── not logical_conjunction(False , False) -> True

logical_nand(False, True ) -> True
 └── not logical_conjunction(False , True ) -> True

logical_nand(True , False) -> True
 └── not logical_conjunction(True  , False) -> True

logical_nand(True , True ) -> False
 └── not logical_conjunction(True  , True ) -> False

I remove the comments

def logical_nand(first_input, second_input):
    return logical_negation(
        logical_conjunction(first_input, second_input)
    )
    return not (first_input and second_input)

I can use any of these two return statements, only the first one will run 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_nand'
```

Logical NAND

returns False, if the first input is True and the second input is True.
returns not (first_input and second_input) which is the Logical Negation (NOT) of the Logical Conjunction (AND) of the first input and the second input, many words.
is the Logical Negation (NOT) of Logical Conjunction (AND) which only returns True, if the first input is True and the second input is True.
is the not of the and of the first input and second input, confusing?
is the negation of and.

examples of Logical NAND

can the website be reached, if the inputs are
- is main server down?
- is backup server down?
is main down?

is backup down?

can reach website?

yes

yes

no

yes

no

yes

no

yes

yes

no

no

yes
safety when mixing household cleaning products, if the inputs are
- is bleach?
- is soap?
is bleach?

is soap?

is safe when mixed?

yes

yes

no

yes

no

yes

no

yes

yes

no

no

yes
fridge alarm, if the inputs are
- door open?
- temperature rose?
door open?

temperature rose?

silent

yes

yes

no

yes

no

yes

no

yes

yes

no

no

yes
approve a transaction, if the inputs are
- amount is larger than normal?
- the recipient is new?
large amount?

new recipient?

approve?

yes

yes

no

yes

no

yes

no

yes

yes

no

no

yes
show content, if the inputs are
- is user younger than 18?
- is the content flagged as adult?
less than 18?

adult content?

show content

yes

yes

no

yes

no

yes

no

yes

yes

no

no

yes
allow 2 processes writing to the same place, if the inputs are
- is process A writing?
- is process B writing?
process A write?

process B write?

allow?

yes

yes

no

yes

no

yes

no

yes

yes

no

no

yes

test_tautology

The truth table for tautology is

first input	second input	return
True	True	True
True	False	True
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 tautology with an assertion for if the first input is True and the second input is True, to test_binary.py

first input	second input	return
True	True	True

        self.assertTrue(nand(False, False))

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


# Exceptions seen

the terminal is my friend, and shows AttributeError

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

truth_table.py does not have tautology in it.

GREEN: make it pass

I add tautology to truth_table.py

def logical_nand(first_input, second_input):
    return logical_negation(
        logical_conjunction(first_input, second_input)
    )
    return not (first_input and second_input)


def tautology(first_input, second_input):
    return True

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

tautology(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_tautology in test_binary.py

first input

second input

return

True

False

True
```
53    def test_tautology(self):
54        tautology = src.truth_table.tautology
55        self.assertTrue(tautology(True, True))
56        self.assertTrue(tautology(True, False))
57
58
59# Exceptions seen
```
the test is still green. tautology returns
- True, 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
- True, if the first input is True
```
tautology(True , False) -> True
tautology(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

first input	second input	return
False	True	True

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


# Exceptions seen

the test is still green. tautology returns True

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

tautology(False, True ) -> True
tautology(True , False) -> True
tautology(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

first input	second input	return
False	False	True

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


# Exceptions seen

still green, there is only one result for this operation.

tautology(False, False) -> True
tautology(False, True ) -> True
tautology(True , False) -> True
tautology(True , True ) -> True

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

Tautology always returns True, it does not care about the inputs. It is the opposite of contradiction which always returns False.

examples of Tautology

work, if the inputs are
- do I have work?
- do I feel like working?
have work?

feel like work?

work?

yes

yes

yes

yes

no

yes

no

yes

yes

no

no

yes
the customer is always right, if the inputs are
- did customer complain?
- is customer new?
complain?

new?

is customer king?

yes

yes

yes

yes

no

yes

no

yes

yes

no

no

yes
the sun is real, if the inputs are
- am I awake?
- is it bright or dark outside?
awake?

bright/dark?

is sun real?

yes

bright

yes

yes

dark

yes

no

bright

yes

no

dark

yes
I can get better, if the inputs are
- am I good?
- have I done this before?
good?

done before?

can I get better?

yes

yes

yes

yes

no

yes

no

yes

yes

no

no

yes
a noun is the name of a person, place or thing, if the inputs are
- is a person?
- is a place or a thing?
person?

place/thing?

noun is a name

yes

place

yes

yes

thing

yes

no

place

yes

no

thing

yes
unconditional love, if the inputs are
- has the person been good?
- does the person deserve love?
been good?

deserving?

love?

yes

yes

yes

yes

no

yes

no

yes

yes

no

no

yes

test_logical_disjunction

The truth table for logical_disjunction is

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

RED: make it fail

I go back to the terminal where the tests are running

I add a test for logical_disjunction with an assertion for if the first input is True and the second input is True, to test_binary.py

first input	second input	return
True	True	True

        self.assertTrue(tautology(False, False))

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


# Exceptions seen

the terminal is my friend, and shows AttributeError

AttributeError: module 'src.truth_table'
                has no attribute 'logical_disjunction'.
                Did you mean: 'logical_conjunction'?

there is no logical_disjunction in truth_table.py in the src folder, yet.

GREEN: make it pass

I add logical_disjunction to truth_table.py

def tautology(first_input, second_input):
    return True


def logical_disjunction(first_input, second_input):
    return True

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

logical_disjunction(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_disjunction in test_binary.py

first input	second input	return
True	False	True

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


# Exceptions seen

the test is still green. logical_disjunction returns

True, 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
True, if the first input is True

so far this is the same as tautology.

logical_disjunction(True , False) -> True
          tautology(True , False) -> True

logical_disjunction(True , True ) -> True
          tautology(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

first input	second input	return
False	True	True

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


# Exceptions seen

the test is still green. logical_disjunction still looks like Tautology, it returns

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

logical_disjunction(False, True ) -> True
          tautology(False, True ) -> True

logical_disjunction(True , False) -> True
          tautology(True , False) -> True

logical_disjunction(True , True ) -> True
          tautology(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	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))


# Exceptions seen

the terminal is my friend, and shows AssertionError

AssertionError: True is not false

because the logical_disjunction function returns True and this assertion expects False.

I add if statements for the new case to logical_disjunction in truth_table.py

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

the test passes because Python checks if first_input is equal to False when if first_input == False: runs

if first_input is NOT equal to False, it leaves the if statement and continues to run the rest of the function - return True then leaves the function since the return statement is the last thing to run in a function

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

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

if first_input is equal to False, it goes to the next line - if second_input == False:, which checks if second_input is equal to False

if second_input is NOT equal to False, it leaves the if statement and continues to run the rest of the function - return True then leaves the function since the return statement is the last thing to run in a function

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

if second_input is equal to False, it goes to the next line - return False then leaves the function since the return statement is the last thing to run in a function

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

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

I add the bool built-in function

def logical_disjunction(first_input, second_input):
    # if first_input == False:
    if bool(first_input) == 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 if statements in terms of True

def logical_disjunction(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 False
    return True

still green.

I remove == True

def logical_disjunction(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 False
    return True

green.

I remove bool

def logical_disjunction(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 False
    return True

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

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_disjunction(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 False
    return True

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 logical_disjunction(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 False
    else:
        return True

green.

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

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

still green.

I move the first if statement below the new one

def logical_disjunction(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:
    # else:
    if not (not first_input and not second_input):
        return True
    if not first_input and not second_input:
        return False

the test is still green.

I change it to an else clause

def logical_disjunction(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:
    # else:
    if not (not first_input and not second_input):
        return True
    # if not first_input and not second_input:
    else:
        return False

still green.

I add a conditional expression (ternary operator)

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

green.

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

I remove True if and else False to make it simpler

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

still green.

not happens 3 times in this statement. I “multiply” it by every symbol in the statement to try to make it simpler

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

the terminal is my friend and shows SyntaxError

SyntaxError: invalid syntax

I cannot negate and this way.

I add SyntaxError to the list of Exceptions seen, in test_binary.py

        self.assertFalse(logical_disjunction(False, False))


# Exceptions seen
# AttributeError
# TypeError
# AssertionError
# SyntaxError

I change not and to or in the logical_disjunction function in truth_table.py

    return (
        (not not first_input)
        # (not and)
        or
        (not not second_input)
    )

the test is green again

I remove not not because they cancel out

    return (
        # (not not first_input)
        first_input
        # (not and)
        or
        # (not not second_input)
        second_input
    )

the test is still green. Do two nots make a right?

logical_disjunction returns not ((not first_input) and (not second_input)) which is the Logical Negation (NOT), of the Logical Conjunction of the Logical Negation of first_input, and the Logical Negation of second_input.

logical_negation(
    logical_conjunction(
        logical_negation(first_input),
        logical_negation(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 second_input is the Logical Negation (NOT) of second_input
- if the second input is True, this part of the statement is False
- if the second input is False, this part of the statement is True

This means that in the four cases

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

not ((not first) and (not second))
not ((not True ) and (not True  ))
not (False       and False       )
not  False       # not logical_conjunction(False, False)
True

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

not ((not first) and (not second))
not ((not True ) and (not False ))
not (False       and True        )
not  False       # not logical_conjunction(False, True)
True

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

not ((not first) and (not second))
not ((not False) and (not True  ))
not (True        and False       )
not  False       # not logical_conjunction(True, False)
True

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

not ((not first) and (not second))
not ((not False) and (not False ))
not (True        and True        )
not  True        # not logical_conjunction(True, True)
False

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

I add a return statement to show this

def logical_disjunction(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:
    # else:
    # if not (not first_input and not second_input):
    #     return True
    # if not first_input and not second_input:
    # else:
    #     return False
    # return (
        # True if
        # not (not first_input and not second_input)
        # else False
    # )
    return logical_negation(
        logical_conjunction(
            logical_negation(first_input),
            logical_negation(second_input)
        )
    )
    return (
        # (not not first_input)
        first_input
        # (not and)
        or
        # (not not second_input)
        second_input
    )

still green.

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

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

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

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

I remove the commented lines

def logical_disjunction(first_input, second_input):
    return logical_negation(
        logical_conjunction(
            logical_negation(first_input),
            logical_negation(second_input)
        )
    )
    return first_input or second_input

I can use any of these two return statements, only the first one will run 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_disjunction'

Logical Disjunction also known as “OR” returns

first_input or second_input.
False, if the first input is False and the 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

examples of Logical Disjunction

the system works, if the inputs are
- is the main system running?
- is the backup system running?
is main running?

is backup running?

is system working?

yes

yes

yes

yes

no

yes

no

yes

yes

no

no

no
emergency room triage, if the inputs are
- is it life threatening?
- is patient a child?
life threat?

child?

treat immediately

yes

yes

yes

yes

no

yes

no

yes

yes

no

no

no
automatic door that opens, if the inputs are
- has keycard?
- entered code?
has keycard?

entered code?

open door

yes

yes

yes

yes

no

yes

no

yes

yes

no

no

no
give discount if the person is already a customer or has a coupon, if the inputs are
- is already a customer?
- has coupon code?
already customer

has coupon

give discount

yes

yes

yes

yes

no

yes

no

yes

yes

no

no

no
elevator moves, if the inputs are
- did I push the button?
- did someone else push the button?
I pushed

someone else pushed

elevator moves

yes

yes

yes

yes

no

yes

no

yes

yes

no

no

no

close the project

I close test_binary.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

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

Three binary operations were written with AND, three with NOT and one was written with 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

code from the chapter

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

what is next?

Would you like test even more binary operations?

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.

is risky?	good reason?	approved
yes	yes	no
yes	no	no
no	yes	yes
no	no	yes

is raining?	feel like walking?	should walk
yes	yes	no
yes	no	no
no	yes	yes
no	no	yes

battery dead?	is there smoke?	beep
yes	yes	no
yes	no	no
no	yes	yes
no	no	yes

update running?	admin?	system can be used
yes	yes	no
yes	no	no
no	yes	yes
no	no	yes