truth table: Binary Operations

Warning

Welcome to the wonderful world of Boolean Logic. If this is new to you, then prepare for headaches and moving closer to the edge of insanity.

This is part of the process as you stretch yourself and learn new things that help you solve problems and see the world in a new way.

Do you still want to continue?

The last chapter covered two types of operations

Nullary Operations which do not take input
Unary Operations which take one input

There are also Binary Operations, they take two inputs. Each input can be False or True which means there are 4 possible ways the inputs can be sent to a binary operation

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

These combinations give 16 binary operations, and each operation returns True or False. The truth table shows the 16 operations covered in these chapters and what they return when they receive input.

return	True, True	True, False	False, True	False, False	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
not second	False	True	False	True	negate_second
not (first or second)	False	False	False	True	logical_nor
(not first or second) and (first or not second)	True	False	False	True	logical_equality
(not first) or second	True	False	True	True	material_implication

preview

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

import src.truth_table
import unittest


class TestBinaryOperations(unittest.TestCase):

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


# Exceptions seen
# AttributeError
# TypeError
# AssertionError
# SyntaxError

truth table: Binary Operations

preview

requirements

Binary Operations

what is next?