booleans: truth table

preview

Sometimes I want programs to make decisions based on inputs or conditions, and can make this happen with if statement. For example, If I want to know if a person can vote, the conditions could be

Is the person alive?
Is the person old enough?

I can add these to a program so that when it gets information about the person, it can make a decision or return output of True for “Yes, they can vote” or False for “No, they can not vote”

The following are exercises on writing conditional expressions in Python using the Truth Table from Mathematics and the assertFalse and assertTrue methods from AssertionError, None and booleans.

All operations from the Truth Table always result in True or False

Here are the tests I have at the end of the chapters

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

    def test_negate_second(self):
        self.assertFalse(src.truth_table.negate_second(True, True))
        self.assertTrue(src.truth_table.negate_second(True, False))
        self.assertFalse(src.truth_table.negate_second(False, True))
        self.assertTrue(src.truth_table.negate_second(False, False))

    def test_logical_nor(self):
        self.assertFalse(src.truth_table.logical_nor(True, True))
        self.assertFalse(src.truth_table.logical_nor(True, False))
        self.assertFalse(src.truth_table.logical_nor(False, True))
        self.assertTrue(src.truth_table.logical_nor(False, False))

    def test_logical_equality(self):
        self.assertTrue(src.truth_table.logical_equality(True, True))
        self.assertFalse(src.truth_table.logical_equality(True, False))
        self.assertFalse(src.truth_table.logical_equality(False, True))
        self.assertTrue(src.truth_table.logical_equality(False, False))

    def test_material_implication(self):
        self.assertTrue(src.truth_table.material_implication(True, True))
        self.assertFalse(src.truth_table.material_implication(True, False))
        self.assertTrue(src.truth_table.material_implication(False, True))
        self.assertTrue(src.truth_table.material_implication(False, False))


# Exceptions seen
# AssertionError
# AttributeError
# TypeError
# SyntaxError

questions about The Truth Table

What is not?
What is and?
What is or?
What is an if statement
What is a conditional expression?
What is a ternary operator?
What are the possible combinations of two inputs?

start the project

I name this project truth_table
I open a terminal
then I make a directory for the project
```
mkdir truth_table
```
the terminal goes back to the command line
```
.../pumping_python
```
I change directory to the project
```
cd truth_table
```
the terminal shows I am now in the truth_table folder
```
.../pumping_python/truth_table
```
I make a folder for the source code
```
mkdir src
```
the terminal goes back to the command line
```
.../pumping_python/truth_table
```
I use touch to make an empty file for the program in the src folder
```
touch src/truth_table.py
```
on Windows without Windows Subsystem for Linux use New-Item src/truth_table.py instead of touch src/truth_table.py
```
New-Item src/truth_table.py
```
the terminal goes back to the command line
```
.../pumping_python/truth_table
```
I make a directory for the tests
```
mkdir tests
```
the terminal goes back to the command line
I use touch to make an empty file in the tests folder to tell Python that it is a Python package

Attention

use 2 underscores (__) before and after init for __init__.py not _init_.py
```
touch tests/__init__.py
```
on Windows without Windows Subsystem for Linux use New-Item tests/__init__.py instead of touch tests/__init__.py
```
New-Item tests/__init__.py
```
the terminal goes back to the command line
I make an empty file for the actual test
```
touch tests/test_truth_table.py
```
on Windows without Windows Subsystem for Linux use New-Item tests/test_truth_table.py instead of touch tests/test_truth_table.py
```
New-Item tests/test_truth_table.py
```
the terminal goes back to the command line
I open test_truth_table.py in the editor of the Integrated Development Environment (IDE)
Tip

I can open a file from the terminal in Visual Studio Code by typing code and the name of the file with
```
code tests/test_truth_table.py
```
test_truth_table.py opens up in the editor

I add the first failing test to test_truth_table.py

import unittest

class TestTruthTable(unittest.TestCase):

    def test_failure(self):
        self.assertFalse(True)

I make a virtual environment in the terminal
```
python3 -m venv .venv
```
on Windows without Windows Subsystem for Linux use python3 -m venv .venv instead of python3 -m venv .venv
```
python -m venv .venv
```
the terminal takes some time then goes back to the command line
I activate the virtual environment
```
source .venv/bin/activate
```
on Windows without Windows Subsystem for Linux use .venv/bin/activate.ps1 instead of source .venv/bin/activate
```
.venv/scripts/activate.ps1
```
the terminal shows
```
(.venv) .../pumping_python/truth_table
```
I upgrade the Python package manager (pip) to the latest version
```
python3 -m pip install --upgrade pip
```
the terminal shows pip being uninstalled then installs the latest version or shows that it is already the latest version
I make a requirements.txt file for the Python programs my project needs
```
echo "pytest-watch" > requirements.txt
```
the terminal goes back to the command line
I use pip to use the requirements file to install pytest-watch
```
python3 -m pip install --requirement requirements.txt
```
on Windows without Windows Subsystem for Linux use python -m pip install --requirement requirements.txt instead of python3 -m pip install --requirement requirements.txt
```
python -m pip install --requirement requirements.txt
```
the terminal shows pip downloads and installs the Python programs that pytest-watch needs to run

I use pytest-watch to run the test

pytest-watch

the terminal shows

================================ FAILURES ================================
_____________________ TestTruthTable.test_failure ________________________

self = <tests.test_truth_table.TestTruthTable testMethod=test_failure>

    def test_failure(self):
>       self.assertFalse(True)
E       AssertionError: True is not false

tests/test_truth_table.py:7: AssertionError
======================== short test summary info =========================
FAILED tests/test_truth_table.py::TestTruthTable::test_failure - AssertionError: True is not false
=========================== 1 failed in X.YZs ============================

I hold ctrl (Windows/Linux) or option or command (MacOS) on the keyboard and use the mouse to click on tests/test_truth_table.py:7 to open it in the editor

I add AssertionError to the list of Exceptions seen in test_truth_table.py

        self.assertFalse(True)


# Exceptions seen
# AssertionError

then I change True to False in the assertion
```
7        self.assertFalse(False)
```
the test passes

I add an import statement

import unittest
import src.truth_table

I CLICK HERE to continue to Truth Table: Nullary and Unary Operations

truth table operations

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 Nullary and Unary Operations?

booleans

truth table: Nullary and Unary Operations