truth table: Binary Operations part 1

The last chapter covered 2 types of operations. Nullary Operations which do not take input, and Unary Operations which take 1 input.

There are also Binary Operations, these take 2 inputs. Each of the inputs in this exercise will be True or False which means there are 4 possible ways the inputs can be sent to an operation

preview

These combinations give 16 binary operations each of which returns True or False based on the inputs it receives. Here are the 16 operations that are covered in these chapters and what they return

Material Implication returns
- not first_input or second_input
- False when first_input is True and second_input is False
Logical Equality returns
- first_input == second_input
- True when first_input and second_input are equal
Logical NOR returns
- not (first_input or second_input)
- True when first_input and second_input are both False
Negate Second returns
- not second_input
- True when second_input is True
Converse Implication returns
- first_input or not second_input
- False when first_input is False and second_input is True
Project First returns
- first_input
- True when first_input is True
Material NonImplication returns
- first_input and not second_input
- True when first_input is False and second_input is True
Exclusive Disjunction returns
- first_input != second_input
- True when first_input and second_input are NOT equal
Logical Disjunction returns
- first_input or second_input
- True when first_input and second_input are both False
Tautology always returns True
Logical NAND returns
- not (first_input and second_input)
- False when first_input and second_input are both True
Negate First returns
- not first_input
- True when first_input is False
Converse NonImplication returns
- not first_input and second_input
- True when first_input is False and second_input is True
Project Second returns
- second_input
- True when second_input is True
Logical Conjunction returns
- first_input and second_input
- True when first_input and second_input are True
Contradiction always returns False

requirements

truth table: Nullary and Unary Operations

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

test_contradiction

RED: make it fail

I add a new TestCase to test_truth_table.py

import unittest
import src.truth_table

class TestNullaryOperations(unittest.TestCase):

    def test_logical_true(self):
        self.assertTrue(src.truth_table.logical_true())

    def test_logical_false(self):
        self.assertFalse(src.truth_table.logical_false())

class TestUnaryOperations(unittest.TestCase):

    def test_logical_identity(self):
        self.assertTrue(src.truth_table.logical_identity(True))
        self.assertFalse(src.truth_table.logical_identity(False))

    def test_logical_negation_aka_not(self):
        self.assertFalse(src.truth_table.logical_negation(True))
        self.assertTrue(src.truth_table.logical_negation(False))

class TestBinaryOperations(unittest.TestCase):

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

# Exceptions seen

the terminal shows AttributeError

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

GREEN: make it pass

I add a function definition to truth_table.py

def logical_negation(the_input):
    return not the_input


def contradiction(the_input):
    return not the_input

the terminal shows TypeError

TypeError: contradiction() takes 1 positional argument but 2 were given

The definition only takes one input, but the test sent two. I add second_input as the second name in parentheses then change argument to first_input for the first input given when the function is called by the test

Tip

In Visual Studio Code I can change all the places that a name is in the file, by using

Find and Replace - ctrl+H on Windows or option+command+F on MacOS or with
Rename Symbol
- Right click on the name you want to change, for example the_input then select Rename Symbol or
- Select the name you want to change then hit :kbd:F2 on your keyboard to rename it

def contradiction(first_input, second_input):
    return not first_input

the test passes. When contradiction gets True as its first input and True as its second input, it returns the opposite of the first input, that means it returns not True which is False

REFACTOR: make it better

I add the second case to test_contradiction in test_truth_table.py, this is when the first input is True and the second input is False
```
27    def test_contradiction(self):
28        self.assertFalse(src.truth_table.contradiction(True, True))
29        self.assertFalse(src.truth_table.contradiction(True, False))
```
the test is still green. contradiction returns False in the two cases where the first input is True
I add the third case, which is when the first input is False and the second input is True
```
27    def test_contradiction(self):
28        self.assertFalse(src.truth_table.contradiction(True, True))
29        self.assertFalse(src.truth_table.contradiction(True, False))
30        self.assertFalse(src.truth_table.contradiction(False, True))
```
the terminal shows AssertionError
```
AssertionError: True is not false
```
so far all three cases of the test expect False, which means contradiction should return False when
- the first input is True and the second input is True
- the first input is True and the second input is False
- the first input is False and the second input is True
I change the return statement in the contradiction function in truth_table.py to return the expectation
```
17def contradiction(first_input, second_input):
18    return False
```
the test passes

I add the fourth case to test_contradiction in test_truth_table.py, this is when the two inputs are False

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


# Exceptions seen

the test is still green!

Contradiction always returns False it does not matter what inputs it gets

test_logical_conjunction

RED: make it fail

I add a test for logical_conjunction in test_truth_table.py with the first case where the two inputs are True

          self.assertFalse(src.truth_table.contradiction(False, False))

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

# Exceptions seen

the terminal shows AttributeError

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

GREEN: make it pass

I add the function in truth_table.py

def contradiction(first_input, second_input):
    return False


def logical_conjunction(first_input, second_input):
    return True

the test . logical_conjunction returns True when the first and second input are both True

REFACTOR: make it better

I add the next case - when the first input is True and the second input is False, to test_logical_conjunction in test_truth_table.py

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

the terminal shows AssertionError

AssertionError: True is not false

I make the logical_conjunction function in truth_table.py return False

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

the terminal shows AssertionError

AssertionError: False is not true

The line that was passing before is now failing

logical_conjunction has to make a choice. It should return

False when the first input and second input are both True
True when the first input is True and the second input is False

I can make it do that with if statements

if statements

An if statement is a way for a program to do something based on something else. I can use them to make a function choose between 2 things, there are written as

if something:
    do this

I add if statements to the logical_conjunction function in truth_table.py

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

the test passes. logical_conjunction returns

False when first_input is True and second_input is False
True when the two inputs are True

I add the case where the first input is False and the second input is True to test_logical_conjunction in test_truth_table.py

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

the terminal shows AssertionError

AssertionError: True is not false

I add another if statement for this case to logical_conjunction in truth_table.py

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

the test passes. logical_conjunction returns

False when first_input is False and second_input is True
False when first_input is True and second_input is False
True when the two inputs are True

I add the last case, which is when the two inputs are False, to test_logical_conjunction in test_truth_table.py

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


# Exceptions seen

the terminal shows AssertionError

AssertionError: True is not false

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

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

the test passes. logical_conjunction returns

False when the two inputs are False
False when first_input is False and second_input is True
False when first_input is True and second_input is False
True when the two inputs are True

I have the same if statement twice - if first_input == False for the 3rd and 4th cases where the first input is False

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

I remove the second one

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

the test is still green

I add an if statement for the first case, where the first and second inputs are both True

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

the terminal still shows green

there are only 2 results for this operation, in the first case the function returns True. In the other 3 cases it returns False.

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

Tip

I can put two if statements together when one is under the other. For example

if something:
    if something_else:

can also be written as

if something and something_else:

I put the two if statements for the one case where the result is True together and use an else clause for the other cases where the first and second inputs are not both True

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

the test is still green

I remove the other if statements then use bool in the first if statement

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

still green. bool checks if the thing in parentheses is True in the background

I remove the commented line then change the first line to make it simpler
```
21def logical_conjunction(first_input, second_input):
22    if first_input and second_input:
23    # if bool(first_input) and bool(second_input):
24        return True
25    else:
26        return False
```
the test is still green
Tip

these if statements are the same
- if something == True:
- if bool(something): == True
- ``if bool(something):
- if something:
Python checks if something is True in the background when I type if something:
I remove the commented line

conditional expressions

Python has ternary operators or conditional expressions which allow me to write the if statement and the else clause as one line

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

the terminal shows green

I remove the other if statements then change the return statement to a simpler form

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

still green!

I remove the second return statement

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

Logical Conjunction also known as and, returns

first_input and second_input
True when the two inputs are both True

Tip

All of the statements below give the same result

this checks if something is True

if something == True:
    return True
else:
    return False

this uses bool to get the boolean of something then checks if the result is True

if bool(something) == True:
    return True
else:
    return False

this checks if bool(something) is True in the background

if bool(something):
    return True
else:
    return False

this checks if something is True in the background

if something:
    return True
else:
    return False

this returns True if something is True
```
return True if something else False
```
this also returns True after checking if something is True in the background
```
return something
```

the last one works because Python tests if something is True in the background same as it does when I type if something:

test_project_second

RED: make it fail

I add a test for another Binary Operation in test_truth_table.py

        self.assertFalse(src.truth_table.logical_conjunction(False, False))

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

# Exceptions seen

the terminal shows AttributeError

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

GREEN: make it pass

I add a definition for the function in truth_table.py

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


def project_second(first_input, second_input):
    return True

the test passes. When the first input is True and the second input is False, this function returns True

REFACTOR: make it better

I add the second case - where the first input is True and the second input False, to test_project_second in test_truth_table.py

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

the terminal shows AssertionError

AssertionError: True is not false

I add an if statement for the case to project_second in truth_table.py

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

the test

project_second returns False when the first input is True and the second input False
it returns True in every other case

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

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

the test is still green

I add the last case - when the two inputs are 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))


# Exceptions seen

the terminal shows AssertionError

AssertionError: True is not false

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

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

the test passes

project_second returns

False when second_input is False
True when second_input is True

It returns the same value as the second input. I add a new return statement to show this

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

the test is still green

I remove the other statements

def project_second(first_input, second_input):
    return second_input

Project Second returns the second input, it always returns

True when the second input is True
False when the second input is False

test_converse_non_implication

RED: make it fail

I add a test for converse_non_implication in test_truth_table.py

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

# Exceptions seen

the terminal shows AttributeError

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

GREEN: make it pass

I add the function to truth_table.py

def project_second(first_input, second_input):
    return second_input


def converse_non_implication(first_input, second_input):
    return False

the test passes. converse_non_implication returns False when the first input is True and the second input is False

REFACTOR: make it better

I add the next case to test_converse_non_implication in test_truth_table.py, when the first input is True and the second input is 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))

the test is still green, because it expects False in both cases

I add the third case - where the first input is False and the second input is True

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

the terminal shows AssertionError

AssertionError: False is not true

I add an if statement to converse_non_implication in truth_table.py

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

the test passes. The converse_non_implication function returns

True when the first input is False and the second input is True
False in all other cases

I add the next case - when the first and second inputs are both False, to test_converse_non_implication in test_truth_table.py

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


# Exceptions seen

the test is still passing

I use and aka logical_conjunction to put the two if statements together in converse_non_implication in truth_table.py

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

the terminal still shows green

I remove the commented lines then change the first line with logical negation and bool

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

still green

I add an else clause

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

the test is still green

I remove the comment and use bool with the first part of the if statement to make it simpler

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

the test is still green

I remove the commented line and make the if statement simpler

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

the terminal still shows green

I use a conditional expression

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

still green

I remove the if statements then use the simpler return statement

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

all tests are still passing

I remove the second return statement

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

Converse NonImplication always returns

not first_input and second_input
the Logical Conjunction of the Negation of the first input and the second input
True only when the first input is False and the second input is True

review

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

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
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
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
Contradiction
- always returns False
- is the opposite or Tautology which always returns True

and

Logical Conjunction is “and”
Logical Negation is “not”

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

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 more binary operations?

truth table: Nullary and Unary Operations

truth table: Binary Operations part 2