truth table

Sometimes I want programs to choose what to do based on inputs or conditions, and can make this happen with if statements. 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?
Is the person a citizen?

I can add these to a program so that when it gets information about the person it returns output of True for “Yes, they can vote” or False for “No, they can not vote” after it looks at the options.

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

These are the underlying operations that make the computer do what it does. All operations from the Truth Table always return True or False.

preview

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

import src.truth_table
import unittest


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


# Exceptions seen
# AssertionError
# AttributeError
# TypeError

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

    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
I make a directory for the project
```
mkdir truth_table
```
the terminal goes back to the command line
I change directory to the project
```
cd truth_table
```
the terminal shows I am in the truth_table folder
```
.../pumping_python/truth_table
```
I make a directory for the source code
```
mkdir src
```
the terminal goes back to the command line
I make a Python file to hold the source code in the src directory
```
touch src/truth_table.py
```
Note

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
I make a directory for the tests
```
mkdir tests
```
the terminal goes back to the command line
I make the tests directory a Python package

Danger

use 2 underscores (__) before and after init for __init__.py not _init_.py
```
touch tests/__init__.py
```
Note

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 a Python file for the tests in the tests directory
```
touch tests/test_truth_table.py
```
Note

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 use the terminal to open a file in the Integrated Development Environment (IDE) by typing the name of the program and the name of the file. That means when I type this in the terminal
```
code tests/test_truth_table.py
```
Visual Studio Code opens test_truth_table.py 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 requirements file for the Python packages I need, in the terminal
```
echo "pytest" > requirements.txt
```
the terminal goes back to the command line
I add pytest-watcher to the file
```
echo "pytest-watcher" >> requirements.txt
```
the terminal goes back to the command line
I setup the project with uv
```
uv init
```
the terminal shows
```
Initialized project `truth-table`
```
then goes back to the command line
I remove main.py from the project because I do not use it
```
rm main.py
```
the terminal goes back to the command line
I install the Python packages I gave in the requirements file
```
uv add --requirement requirements.txt
```
the terminal shows it installed the Python packages

I use pytest-watcher to run the tests automatically

uv run pytest-watcher . --now

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 add AssertionError to the list of Exceptions seen in test_truth_table.py

class TestTruthTable(unittest.TestCase):

    def test_failure(self):
        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 src.truth_table
import unittest

Click Here to continue to Nullary and Unary Operations

truth table operations

what is next?

Nullary and Unary Operations

what are booleans?

truth table: Nullary and Unary Operations