truth table: test_truth_table_tests

requirements

Binary Operations part 4

how to get back to the automated tests

If your tests stopped after the previous chapter, heres’s how to get back to the tests

Make sure you are in the pumping_python folder with pwd in the terminal
```
pwd
```
if the terminal shows anything other than
```
.../pumping_python
```
you need to change directory to the pumping_python folder
Once in the pumping_python directory, change directory to the project
```
cd truth_table
```
the terminal shows
```
.../pumping_python/truth_table
```
activate the Virtual Environment
```
source .venv/bin/activate
```
on Windows without Windows Subsystem for Linux use .venv/scripts/activate.ps1 instead of source .venv/bin/activate
```
.venv/scripts/activate.ps1
```
when the Virtual Environment is activated, the terminal shows
```
(.venv) .../pumping_python/truth_table
```
run the tests
```
pytest-watch
```

I want to write a program that makes the tests in test_truth_table.py pass without looking at them

RED: make it fail

I close test_truth_table.py
then delete everything in truth_table.py, the terminal shows 20 failures, I start with the last one
```
AttributeError: module 'src.truth_table' has no attribute 'tautology'
```

GREEN: make it pass

I add the name to truth_table.py

1tautology

the terminal shows NameError

NameError: name 'tautology' is not defined

I point the name to None

tautology = None

the terminal shows TypeError

TypeError: 'NoneType' object is not callable

I make tautology a function

def tautology():
    return None

the terminal shows TypeError

TypeError: tautology() takes 0 positional arguments but 2 were given

I add names in parentheses for the function to take input arguments

def tautology(first_input, second_input):
    return None

the terminal shows AssertionError

AssertionError: None is not true

I change None to True in the return statement

def tautology(first_input, second_input):
    return True

the terminal shows AttributeError

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

I add the function using the solution I just used for tautology

def tautology(first_input, second_input):
    return True


def project_second(first_input, second_input):
    return True

the terminal shows AssertionError

AssertionError: True is not false

I change the return statement

def project_second(first_input, second_input):
    return False

the terminal shows AssertionError

AssertionError: False is not true

The expectation of the test changes. I want to see the difference between the inputs and the expected output

def project_second(first_input, second_input):
    return first_input, second_input

the terminal shows AssertionError

AssertionError: (True, False) is not false

second_input is False, I remove first_input from the return statement

def project_second(first_input, second_input):
    return second_input

the terminal shows AttributeError

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

I add a function for it

def project_second(first_input, second_input):
    return second_input


def project_first(first_input, second_input):
    return first_input, second_input

the terminal shows AssertionError

AssertionError: (False, True) is not false

first_input is False

I remove second_input from the return statement

def project_first(first_input, second_input):
    return first_input

the terminal shows AttributeError

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

I add a function for negate_second

def project_first(first_input, second_input):
    return first_input


def negate_second(first_input, second_input):
    return first_input, second_input

the terminal shows AssertionError

AssertionError: (True, True) is not false

I add an if statement to negate_second

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

the terminal shows AssertionError

AssertionError: (False, True) is not false

I add another if statement

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

the terminal shows AttributeError

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

I add a function definition for it

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


def negate_first(first_input, second_input):
    return first_input, second_input

the terminal shows AssertionError

AssertionError: (True, True)

I add an if statement

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

the terminal shows AssertionError

AssertionError: (True, False) is not false

I add an if statement

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

the terminal shows AttributeError

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

I add a function for material_non_implication

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


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

the terminal shows AssertionError

AssertionError: (True, True) is not false

I add an if statement

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

the terminal shows AssertionError

AssertionError: (False, True) is not false

I add another if statement

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

the terminal shows AssertionError

AssertionError: (False, False) is not false

I add an if statement for it

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

the terminal shows AttributeError

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

I add a function for material_implication

    if (first_input, second_input) == (False, False): return False
    return first_input, second_input


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

the terminal shows AssertionError

AssertionError: (True, False) is not false

I add an if statement

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

the terminal shows AttributeError

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

I add a function for logical_nor

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


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

the terminal shows AssertionError

AssertionError: (True, True) is not false

I add an if statement

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

the terminal shows AssertionError

AssertionError: (True, False) is not false

I add another if statement

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

the terminal shows AssertionError

AssertionError: (False, True) is not false

I add an if statement

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

the terminal shows AttributeError

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

I add a function for logical_nand

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


def logical_nand(first_input, second_input):
    return first_input, second_input

the terminal shows AssertionError

AssertionError: (True, True) is not false

I add an if statement

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

the terminal shows AttributeError

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

I add the function

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


def logical_equality(first_input, second_input):
    return first_input, second_input

the terminal shows AssertionError

AssertionError: (True, False) is not false

I add an if statement

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

the terminal shows AssertionError

AssertionError: (False, True) is not false

I add another if statement

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

the terminal shows AttributeError

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

I add a function for logical_disjunction

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


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

the terminal shows AssertionError

AssertionError: (False, False) is not false

I add an if statement

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

the terminal shows AttributeError

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

I add a function for logical_conjunction

    if (first_input, second_input) == (False, False): return False
    return first_input, second_input


def logical_conjunction(first_input, second_input):
    return first_input, second_input

the terminal shows AssertionError

AssertionError: (True, False) is not false

I add an if statement

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

the terminal shows AssertionError

AssertionError: (False, True) is not false

I add an if statement

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

the terminal shows AssertionError

AssertionError: (False, False) is not false

I add another if statement

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

the terminal shows AttributeError

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

I add a function for exclusive_disjunction

    if (first_input, second_input) == (False, False): return False
    return first_input, second_input


def exclusive_disjunction(first_input, second_input):
    return first_input, second_input

the terminal shows AssertionError

AssertionError: (True, True) is not false

I add an if statement

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

the terminal shows AssertionError

AssertionError: (False, False) is not false

I add another if statement

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

the terminal shows AttributeError

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

I add a definition for the converse_non_implication function

    if (first_input, second_input) == (False, False): return False
    return first_input, second_input


def converse_non_implication(first_input, second_input):
    return first_input, second_input

the terminal shows AssertionError

AssertionError: (True, True) is not false

I add an if statement

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

the terminal shows AssertionError

AssertionError: (True, False) is not false

I add another if statement

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

the terminal shows AssertionError

AssertionError: (False, False) is not false

I add an if statement

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

the terminal shows AttributeError

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

I add the function for converse_implication

    if (first_input, second_input) == (False, False): return False
    return first_input, second_input


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

the terminal shows AssertionError

AssertionError: (False, True) is not false

I add an if statement

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

the terminal shows AttributeError

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

I add a function for contradiction

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


def contradiction(first_input, second_input):
    return first_input, second_input

the terminal shows AssertionError

AssertionError: (True, True) is not false

I add an if statement

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

the terminal shows AssertionError

AssertionError: (True, False) is not false

I add another if statement

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

the terminal shows AssertionError

AssertionError: (False, True) is not false

I add another if statement

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

the terminal shows AssertionError

AssertionError: (False, False) is not false

I add an if statement

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

the terminal shows AttributeError

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

I add a function for logical_negation

    if (first_input, second_input) == (False, False): return False
    return first_input, second_input


def logical_negation(first_input, second_input):
    return first_input, second_input

the terminal shows TypeError

TypeError: logical_negation() missing 1 required positional argument: 'second_input'

I remove second_input from the parentheses, to make the function take only 1 input,

def logical_negation(first_input):
    return first_input

the terminal shows AssertionError

AssertionError: True is not false

I add “not” to the return statement

def logical_negation(first_input):
    return not first_input

the terminal shows AttributeError

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

I add a function for logical_identity

def logical_negation(first_input):
    return not first_input


def logical_identity(the_input):
    return not the_input

the terminal shows AssertionError

AssertionError: False is not true

I remove “not” from the return statement

def logical_identity(the_input):
    return the_input

the terminal shows AttributeError

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

I add a function for logical_true

def logical_identity(the_input):
    return the_input


def logical_true(the_input):
    return the_input

the terminal shows TypeError

TypeError: logical_true() missing 1 required positional argument: 'x'

I remove first_input from the parentheses, this function does not take input, I change the return statement

def logical_true():
    return None

the terminal shows AssertionError

AssertionError: None is not true

I change None to True in the return statement

def logical_true():
    return True

the terminal shows AttributeError

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

I add a function for logical_false
```
101def logical_true():
102    return True
103
104
105def logical_false():
106    return False
```
the terminal shows green! All tests are passing and the world is a better place than when I started.

REFACTOR: make it better

I can refactor the functions I have, to make them simpler since all the tests are passing

logical_false, logical_true, logical_identity and logical_negation are already simple
I change the name of the input in Logical Negation
Tip

In Visual Studio Code I can change everywhere a name is by using
- Find and Replace - ctrl+H on Windows or option+command+F on MacOS
- Rename Symbol
  - Right click on the name you want to change, for example first_input then select Rename Symbol or
  - Select the name you want to change then hit F2 to rename it
```
93def logical_negation(the_input):
94    return not the_input
```

contradiction returns False in 4 cases, with 2 inputs there are only 4 cases. I add a return statement

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

the test is still green. I remove the other lines in the function

def contradiction(first_input, second_input):
    return False


def logical_negation(x):
    return not first_input

converse_implication returns False in only one case, I return the logical negation of the if statement, for the 3 cases that return True

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

still green. I remove the other statements

def converse_implication(first_input, second_input):
    return (first_input, second_input) != (False, True)


def contradiction(first_input, second_input):
    return False

converse_non_implication has only one case that returns True, it is the missing case. I add a return statement for it

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

the terminal still shows green and I remove the other lines

def converse_non_implication(first_input, second_input):
    return (first_input, second_input) == (False, True)


def converse_implication(first_input, second_input):
    return (first_input, second_input) != (False, True)

exclusive_disjunction has two if statements. I put them together to make one if statement

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

the test is still green. I remove the other if statements then return the logical negation of the if statement

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


def converse_non_implication(first_input, second_input):
    return (first_input, second_input) == (False, True)

the test is still green, I remove the other lines

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


def converse_non_implication(first_input, second_input):
    return (first_input, second_input) == (False, True)

logical_conjunction only has one case that returns True, it is the missing case. I add a return statement for it

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

still green, I remove the other statements

def logical_conjunction(first_input, second_input):
    return (first_input, second_input) == (True, True)


def exclusive_disjunction(first_input, second_input):
    return (

logical_disjunction only has one case that returns False, I add a return statement for the opposite of it which covers the other 3 cases

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

the terminal still shows green. I remove the other lines

def logical_disjunction(first_input, second_input):
    return (first_input, second_input) != (False, False)


def logical_conjunction(first_input, second_input):
    return (first_input, second_input) == (True, True)

logical_equality has two if statements. I use what I know from exclusive_disjunction to add a return statement

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

the terminal still shows green. I remove the other lines

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


def logical_disjunction(first_input, second_input):
    return (first_input, second_input) != (False, False)

logical_nand only has one case that returns False, I add a return statement for its opposite which covers the other 3 cases

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

still green. I remove the other lines

def logical_nand(first_input, second_input):
    return (first_input, second_input) != (True, True)


def logical_equality(first_input, second_input):
    return (

logical_nor only has one case that returns True, I add a return statement for it

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

still green, I remove the other statements

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


def logical_nand(first_input, second_input):
    return (first_input, second_input) != (True, True)

material_implication has only one case that returns False, I add a return statement for the other 3

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

the test is still green. I remove the other statements

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


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

material_non_implication has 3 cases that return False. I add a return statement for the missing case that returns True

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

the terminal still shows green. I remove the other statements

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


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

first_input is True in the 2 cases where negate_first returns False, I add an if statement for them

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

the test is still green. I remove the other if statements, then add a simpler return statement

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

the test is still green, I remove the other statements

def negate_first(first_input, second_input):
    return first_input != True


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

second_input is True in the 2 cases where negate_second returns False. I add a return statement like the one from negate_first

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

still green. I remove the other statements

def negate_second(first_input, second_input):
    return second_input != True


def negate_first(first_input, second_input):
    return first_input != True

project_second, project_first and tautology are already simple

I change the return statement in negate_second to make it simpler

def negate_second(first_input, second_input):
    return not second_input == True
    return second_input != True

when not second_input is True it means the return statement is True == True which is a duplication. I remove the second part of the statement and the second return statement

def negate_second(first_input, second_input):
    return not second_input


def negate_first(first_input, second_input):

the test is still green

I do the same thing with negate_first

def negate_first(first_input, second_input):
    return not first_input
    return first_input != True

still green. I remove the second return statement

def negate_first(first_input, second_input):
    return not first_input


def material_non_implication(first_input, second_input):

I use this with material_non_implication

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

the terminal shows all tests are still passing. I remove the second return statement

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


def material_implication(first_input, second_input):

I try it with material_implication

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

the terminal shows AssertionError

AssertionError: False is not true

Not good! I change “and” to “or”

def material_implication(first_input, second_input):
    return not first_input or second_input
    return (first_input, second_input) != (True, False)

the test is green again. Note to self - use “or” the next time I see != in these tests. I remove the other return statement

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


def logical_nor(first_input, second_input):

I do the same thing with logical_nor

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

the test is still green. I remove the second return statement and change the first return statement in terms of “not” since it happens 2 times

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

the terminal shows SyntaxError

SyntaxError: invalid syntax

I comment the line out then factor out “not”

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

the terminal still shows green. I remove the other statements

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


def logical_nand(first_input, second_input):

I add a return statement to logical_nand

def logical_nand(first_input, second_input):
    return not first_input or not second_input
    return (first_input, second_input) != (True, True)

the test is still green, I remove the second return statement then factor out “not” in the first

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

still green. I remove the other return statements

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


def logical_equality(first_input, second_input):

I add a return statement to logical_equality

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

the test is still green, I remove the other return statement

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


def logical_disjunction(first_input, second_input):

I do the same thing with logical_disjunction

def logical_disjunction(first_input, second_input):
    return first_input or second_input
    return (first_input, second_input) != (False, False)

still green. I remove the other return statement

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


def logical_conjunction(first_input, second_input):

on to logical_conjunction

def logical_conjunction(first_input, second_input):
    return first_input and second_input
    return (first_input, second_input) == (True, True)

the terminal still shows green. I remove the other return statement

def logical_conjunction(first_input, second_input):
    return first_input and second_input


def exclusive_disjunction(first_input, second_input):

I add a return statement to exclusive_disjunction

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

still green. I remove the second return statement then factor out “not” from the first part of the statement

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

the test is still green. I remove the commented line

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


def converse_non_implication(first_input, second_input):

I add a simpler return statement to converse_non_implication

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

still green. I remove the other line

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


def converse_implication(first_input, second_input):

time for converse_implication

def converse_implication(first_input, second_input):
    return first_input or not second_input
    return (first_input, second_input) != (False, True)

I remove the second return statement

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


def contradiction(first_input, second_input):

all the tests are still passing

close the project

I close the file(s) I had open in the editor(s)
I exit the tests in the terminal with Ctrl+C on the keyboard
I deactivate the virtual environment
```
deactivate
```
the terminal goes back to the command line, (.venv) is no longer on the left side
```
.../pumping_python/truth_table
```
I change directory to the parent of truth_table
```
cd ..
```
the terminal shows
```
.../pumping_python
```
I am back in the pumping_python directory

review

I ran tests using booleans which can be True or False for the operations of the Truth Table from Mathematics

there are 2 nullary operations, they do not take input and always return the same thing, they are constant
- Logical False always returns False
- Logical True always returns True
there are 2 unary operations, they take one input
- Logical Identity returns its input as output
- Logical Negation returns the negation of its input as output
there are 16 binary operations, they each take 2 inputs, in this case I named the second input second_input and the first one first_input
- Contradiction
  - always returns False
  - is the opposite or Tautology which always returns True
- Converse Implication
  - returns first_input or not second_input
  - returns False when first_input is False and second_input is True
  - is the opposite or Logical Negation of Converse NonImplication which only returns True when first_input is False and second_input is True
- Converse NonImplication
  - returns not first_input and second_input
  - returns True when first_input is False and second_input is True
  - is the opposite or Logical Negation of Converse Implication which only returns False when first_input is False and second_input is True
- Exclusive Disjunction
  - returns first_input != second_input
  - returns True when first_input and second_input are NOT equal
  - is the opposite or Logical Negation of Logical Equality which only returns True when the two inputs are equal
- Logical Conjunction returns
  - returns first_input and second_input
  - returns True when first_input and second_input are True
  - is the opposite or Logical Negation of Logical NAND which only returns False when the two inputs are True
- Logical Disjunction
  - returns first_input or second_input
  - returns True when first_input and second_input are both False
  - is the opposite or Logical Negation of Logical NOR which only returns True when the two inputs are False
- Logical Equality
  - returns first_input == second_input
  - returns True when first_input and second_input are equal
  - is the opposite or Logical Negation of Exclusive Disjunction (Exclusive OR) which only returns True when the two inputs are NOT equal
- Logical NAND
  - returns not (first_input and second_input)
  - returns False when first_input and second_input are both True
  - is the opposite or Logical Negation (not) of Logical Conjunction (and) which only returns True when the two inputs are True
- Logical NOR
  - returns not (first_input or second_input)
  - returns True when first_input and second_input are both False
  - is the opposite or Logical Negation of Logical Disjunction which only returns False when the two inputs are False
- Material Implication
  - returns not first_input or second_input
  - returns False when first_input is True and second_input is False
  - is the opposite or Logical Negation of Material NonImplication which returns True only when first_input is True and second_input is False
- Material NonImplication
  - returns first_input and not second_input
  - returns True when first_input is False and second_input is True
  - is the opposite or Logical Negation of Material or Logical Implication which only returns False when first_input is True and second_input is False
- Negate First
  - returns not first_input
  - returns True when first_input is False
  - is the opposite or Logical Negation of Project First which only returns True when first_input is True
- Negate Second
  - returns not second_input
  - returns True when second_input is True
  - is the opposite or Logical Negation of Project Second which only returns True when second_input is True
- Project First
  - returns first_input
  - returns True when first_input is True
  - is the opposite or Logical Negation of Negate First which only returns True when first_input is False
- Project Second
  - returns second_input
  - returns True when second_input is True
  - is the opposite or Logical Negation of Negate Second which only returns True when second_input is False
- Tautology
  - always returns True
  - is the opposite or Logical Negation of Contradiction which always returns False

and

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

code from the chapter

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

what is next?

you now know

Would you like to test making a calculator?

please leave a review

truth table: Binary Operations part 4

functions