truth table: Binary Operations 3

requirements

preview

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

import src.truth_table
import unittest


class TestBinaryOperations(unittest.TestCase):

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

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

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

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

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

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

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

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

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

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

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

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


# Exceptions seen
# AttributeError
# TypeError
# AssertionError
# SyntaxError

continue the project

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

I run the tests with pytest-watcher

uv run pytest-watcher . --now

the terminal is my friend, and shows

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

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

======================== 12 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 in the editor

test_exclusive_disjunction

RED: make it fail

I add a new test to test_binary.py

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

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


# Exceptions seen

the terminal is my friend, and shows AttributeError

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

GREEN: make it pass

I add exclusive_disjunction to truth_table.py

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


def exclusive_disjunction(first_input, second_input):
    return False

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

first input	second input	return
True	True	False

REFACTOR: make it better

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

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

the terminal is my friend, and shows AssertionError

AssertionError: False is not true

I add if statements to exclusive_disjunction in truth_table.py
```
51def exclusive_disjunction(first_input, second_input):
52    if first_input == True:
53        if second_input == False:
54            return True
55    return False
```
the test passes. exclusive_disjunction returns
- True, if the first input is True and the second input is False
- False, if the first input is True and the second input is True
first input

second input

return

True

True

False

True

False

True

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

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

the terminal is my friend, and shows AssertionError

AssertionError: False is not true

I add if statements to exclusive_disjunction in truth_table.py
```
51def exclusive_disjunction(first_input, second_input):
52    if first_input == False:
53        if second_input == True:
54            return True
55    if first_input == True:
56        if second_input == False:
57            return True
58    return False
```
the test passes. exclusive_disjunction returns
- True, if the first input is False and the second input is True
- True, if the first input is True and the second input is False
- False, if the first input is True and the second input is True
first input

second input

return

True

True

False

True

False

True

False

True

True

I add an assertion for the last case, which is when the first input is False and the second input is False to test_exclusive_disjunction, in test_binary.py

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


# Exceptions seen

the test is still green. exclusive_disjunction returns

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

I put the first two if statements together to make them simpler in exclusive_disjunction in truth_table.py

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

the test is still green

I do the same thing with the next two if statements

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

still green

I add not to the first if statement

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

green

I do the same thing to the second if statement

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

still green

I use the bool built-in function

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

green

I remove == True

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

still green

I remove bool

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

the test is still green

I use Logical Disjunction to put the two if statements together because they both return True

Tip

I can put two if statements together with Logical Disjunction (or) when they are at the same indentation level and return the same thing.

For example

if something:
    return this
if something_else:
    return this

can also be written as

if something or something_else:
    return this

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

still green

I use a conditional expression

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

green

I remove the other statements in the function and make the ternary operator simpler

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

why is the grass greener on the other side?

I remove the second return statement

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

still green

exclusive_disjunction returns False when first_input and second_input are the same and returns True, if they are NOT. I add an if statement to show this with the equality symbol (2 equal signs together =+=)

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

the test is still green

I change the new if statement to a simple return statement

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

still green

I remove the commented lines, then use an even simpler return statement with the NOT equal symbol (!=) (exclamation mark and equal symbol !+= on the keyboard)

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

Exclusive Disjunction returns

True, if the first input is NOT EQUAL to the second input
False, if the first input is EQUAL to the second input
first_input != second_input - which reads as first input is NOT equal to second input
not (first_input == second_input) - which reads as the Logical Negation of the Logical Equality of the first input and the second input
(not first_input and second_input) or (first_input and not second_input) which is the Logical Disjunction of the Logical Conjunction of the Logical Negation of the first input, and the second input, and the Logical Conjunction of the first input and the Logical Negation of the second input. Wow! That’s a lot.

All of the above statements mean the same thing. Exclusive Disjunction is also known as Exclusive OR or XOR. Would “Logical Inequality” be a better name?

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

examples of Exclusive Disjunction

two light switches for one bulb, if the inputs are
- is switch A on?
- is switch B on?
switch A?

switch B?

bulb

on

on

off

on

off

on

off

on

on

off

off

off
magnets attract or repel, if the inputs are
- what is the direction of magnet A?
- what is the direction of magnet B?
magnet A?

magnet B?

attract/repel

north

north

repel

north

south

attract

south

north

attract

south

south

repel
a coin toss, if the inputs are
- my choice
- your choice
my choice

your choice

there is a winner

heads

heads

no

heads

tails

yes

tails

heads

yes

tails

tails

no
two people meet at a door that can only take one person at a time, if the inputs are
- I go
- You go
I go

you go

we both go

go

go

no

go

stop

yes

stop

go

yes

stop

stop

no
A broken vending machine, if the inputs are
- did I put money in the machine?
- did I get what I picked?
I paid

I got what I want

machine is broken

yes

yes

no

yes

no

yes

no

yes

yes

no

no

no

test_material_non_implication

RED: make it fail

I add another test to test_binary.py

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

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


# Exceptions seen

the terminal is my friend, and shows AttributeError

AttributeError: module 'src.truth_table' has no attribute 'material_non_implication'. Did you mean: 'converse_non_implication'?

GREEN: make it pass

I add material_non_implication to truth_table.py

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


def material_non_implication(first_input, second_input):
    return False

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

first input	second input	return
True	True	False

REFACTOR: make it better

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

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

the terminal is my friend, and shows AssertionError

AssertionError: False is not true

I add an if statement to material_non_implication in truth_table.py
```
61def material_non_implication(first_input, second_input):
62    if first_input == True:
63        if second_input == False:
64            return True
65    return False
```
the test passes. material_non_implication returns
- True, if the first input is True and the second input is False
- False, if the first input is True and the second input is True
first input

second input

return

True

True

False

True

False

True

I add an assertion for the third case, where the first input is False and the second input is True in test_binary.py

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

the test is still green. material_non_implication returns

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

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

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

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


# Exceptions seen

still green. material_non_implication returns

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

I change the two if statements to one, in truth_table.py

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

green

I add not

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

still green

I use the bool built-in function

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

the test is still green

I remove == True

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

still green

I remove bool

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

green

I add a conditional expression

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

still green

I make the statement simpler

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

the test is still green

I remove the other statement in the function

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

Material NonImplication

returns first_input and not second_input which is the Logical Conjunction of the first input and the Logical Negation of the second input
returns True, only if the first input is True and the second input is False
is the Logical Negation of Material/Logical Implication which returns False only if the first input is True and the second input is False
can be thought of as a claim that does not deliver

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

examples of Material NonImplication

A broken promise, if the inputs are
- did I make a promise?
- did I do something?
I promised

I did something

broken promise

yes

yes

no

yes

no

yes

no

yes

no

no

no

no
A false alarm, if the inputs are
- did alarm ring?
- was there a bad event?
alarm rang

bad event

false alarm

yes

yes

no

yes

no

yes

no

yes

no (alarm is broken)

no

no

no
the boy who cried wolf, if the inputs
- did the boy cry?
- was there a wolf?
boy cried

wolf

boy cried wolf

yes

yes

no

yes

no

yes

no

yes

no

no

no

no

Note

return first_input and not second_input returns the Logical Conjunction of the first input and the Logical Negation of the second input. This means that in the 4 cases

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

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

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

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

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

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

if the first input is False and the second input is False, material_non_implication returns
```
first and not second
False and not False
False and True      # logical_conjunction(False, True)
False               # logical_conjunction(False, True)
```
first

second

not second

first and (not second)

True

True

False

False

True

False

True

True

False

True

False

False

False

False

True

False

test_project_first

RED: make it fail

I add a new test in test_binary.py

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

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


# Exceptions seen

the terminal is my friend, and shows AttributeError

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

GREEN: make it pass

I add a function for project_first in truth_table.py

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


def project_first(first_input, second_input):
    return True

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

first input	second input	return
True	True	True

REFACTOR: make it better

I add the second case to test_project_first in test_binary.py
```
115    def test_project_first(self):
116        self.assertTrue(src.truth_table.project_first(True, True))
117        self.assertTrue(src.truth_table.project_first(True, False))
```
the test is still green. project_first 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
first input

second input

return

True

True

True

True

False

True

on to the next case

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

the terminal is my friend, and shows AssertionError

AssertionError: True is not false

I add if statements for this case to project_first in truth_table.py
```
65def project_first(first_input, second_input):
66    if first_input == False:
67        if second_input == True:
68            return False
69    return True
```
the test passes. project_first returns
- False, if the first input is False and the second input is True
- True, if the first input is True
first input

second input

return

True

True

True

True

False

True

False

True

False

I add an assertion for the last case to test_project_first in test_binary.py

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


# Exceptions seen

the terminal is my friend, and shows AssertionError

AssertionError: True is not false

I add more if statements to project_first in truth_table.py
```
65def project_first(first_input, second_input):
66    if first_input == False:
67        if second_input == False:
68            return False
69        if second_input == True:
70            return False
71    return True
```
the test passes. project_first returns
- False, if the first input is False and the second input is False
- False, if the first input is False and the second input is True
- False, if the first input is False
- True, if the first input is True
- the first input in every case

I add a return statement

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

the test is still green

I remove the other statements

def project_first(first_input, second_input):
    return first_input

Project First always returns the first input, like Project Second which always returns the second input

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

examples of Project First

did the event happen, if the inputs are
- did the event happen?
- did we get a notification about it?
event

notification

event happened

yes

yes

yes

yes

no

yes

no

yes

no (notification is broken)

no

no

no
able to login with or without Multi Factor Authentication, if the inputs are
- did user provide the right password?
- does user have MFA?
right password

right MFA code

log in

yes

yes

yes

yes

no

yes

no

yes

no (how did user get the MFA code?)

no

no

no
my actions, if the inputs are
- what I want to do?
- what you think I should do?
what I want

your thoughts

what happens

yes

yes

yes

yes

no

yes

no

yes

no

no

no

no
autocorrect, if the inputs are
- autocorrect suggests a word
- I write what I want
autocorrect

what I want

what I get

yes

yes

yes

yes

no

yes

no

yes

no

no

no

no

test_converse_implication

RED: make it fail

I add a new test to test_binary.py

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

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


# Exceptions seen

the terminal is my friend, and shows AttributeError

AttributeError: module 'src.truth_table' has no attribute 'converse_implication'. Did you mean: 'converse_non_implication'?

GREEN: make it pass

I add a function for converse_implication to truth_table.py

def project_first(first_input, second_input):
    return first_input


def converse_implication(first_input, second_input):
    return True

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

first input	second input	return
True	True	True

REFACTOR: make it better

I add the second case to test_converse_implication in test_binary.py
```
121    def test_converse_implication(self):
122        self.assertTrue(src.truth_table.converse_implication(True, True))
123        self.assertTrue(src.truth_table.converse_implication(True, False))
```
the test is still green. converse_implication 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

time for the next case

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

the terminal is my friend, and shows AssertionError

AssertionError: True is not false

I add if statements to converse_implication in truth_table.py
```
69def converse_implication(first_input, second_input):
70    if first_input == False:
71        if second_input == True:
72            return False
73    return True
```
the test passes. converse_implication returns
- False, if the first input is False and the second input is True
- True, if the first input is True
first input

second input

return

True

True

True

True

False

True

I add an assertion for the last case to test_converse_implication in test_binary.py

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


# Exceptions seen

the test is still green. converse_implication returns

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

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

I change the two if statements to one in truth_table.py

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

still green

I use not to write the if statement with True

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

green

I use the bool built-in function

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

still green

I remove == True

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

the test is still green

I remove bool

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

do you like green eggs and ham?

I add the opposite of the if statement for the second return statement

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

still green

I move the new if statement to the top

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

green

I add a conditional expression

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

still green

I remove the other statements and write a simpler conditional expression

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

the test is still green

I remove the commented lines and “multiply not” by the symbols in the parentheses

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

the terminal is my friend, and shows SyntaxError

SyntaxError: invalid syntax

I change “not and” to “or” to be correct

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

back to green

I remove the other return statement then remove not not because they cancel out - the negation of the negation of something is something

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

the test is still green

I remove the other return statement

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

Converse Implication returns

first_input or not second_input
False, only if the first input is False and the second input is True
the Logical Disjunction of the first input and the Logical Negation of the second input
It is the opposite of Converse NonImplication which always returns not first_input and second_input or True, only if the first input is False and the second input is True

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

examples of Converse Implication

I cannot get a table at a restaurant, if the inputs are
- do I have a reservation?
- is the place full?
reservation

place is full

I get a table

yes

yes

yes

yes

no

yes

no

yes

no

no

no

yes
sleep through alarm, if the inputs are
- am I too deep in sleep to hear the alarm?
- is the alarm ringing?
too tired

alarm rings

I sleep

yes

yes

yes

yes

no

yes

no

yes

no

no

no

yes
staying dry outside, if the inputs are
- do I have an umbrella?
- is it raining?
umbrella?

raining?

dry/wet

yes

yes

dry

yes

no

dry

no

yes

wet

no

no

dry

more about Exclusive Disjunction

Exclusive Disjunction can also be thought of as

return (
    converse_non_implication(first_input, second_input)
    or
    material_non_implication(first_input, second_input)
)

because

converse_non_implication returns not first_input and second_input
material_non_implication returns first_input and not second_input

return (not first_input and second_input) or (first_input and not second_input) can be thought of as the logical_disjunction of converse_non_implication and material_non_implication

logical_disjunction(
    converse_non_implication(first_input, second_input),
    material_non_implication(first_input, second_input)
)

This means that in the 4 cases

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

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

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

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

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

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

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

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

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

close the project

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

review

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

Converse Implication
- returns first_input or not second_input
- returns False if first_input is False and second_input is True
- is the opposite (Logical Negation) of Converse NonImplication which returns True only if first_input is False and second_input is True
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 opposite (Logical Negation) 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 NonImplication
- returns first_input and not second_input
- returns True only if first_input is True and second_input is False
- is the opposite (Logical Negation) of Material/Logical Implication which returns False only if first_input is True and second_input is False
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 opposite (Logical Negation) 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 opposite (Logical Negation) 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 opposite (Logical Negation) 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 opposite (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 opposite (Logical Negation) 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 NonImplication
- returns not first_input and second_input
- returns True only if first_input is False and second_input is True
- is the opposite (Logical Negation) of Converse Implication which returns False if first_input is False and second_input is True
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 opposite (Logical Negation) 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 opposite (Logical Negation) 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 opposite (Logical Negation) of Tautology which always returns True
first input

second input

return

True

True

False

True

False

False

False

True

False

False

False

False

and

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

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

code from the chapter

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

what is next?

Would you like to test the last 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

magnet A?	magnet B?	attract/repel
north	north	repel
north	south	attract
south	north	attract
south	south	repel

right password	right MFA code	log in
yes	yes	yes
yes	no	yes
no	yes	no (how did user get the MFA code?)
no	no	no

switch A?	switch B?	bulb
on	on	off
on	off	on
off	on	on
off	off	off

my choice	your choice	there is a winner
heads	heads	no
heads	tails	yes
tails	heads	yes
tails	tails	no

I go	you go	we both go
go	go	no
go	stop	yes
stop	go	yes
stop	stop	no

alarm rang	bad event	false alarm
yes	yes	no
yes	no	yes
no	yes	no (alarm is broken)
no	no	no