---

---

---

truth table: Binary Operations 3

---

requirements

Binary Operations 2

---

preview

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

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


# Exceptions seen
# AttributeError
# TypeError
# AssertionError
# SyntaxError

---

continue the project

• Make sure you are in the pumping_python folder with pwd in the terminal

  pwd
  

  if the terminal does not show

  .../pumping_python
  

  change directory to the pumping_python folder

• Once in pumping_python, change directory to the project

  cd truth_table
  

  the terminal shows

  .../pumping_python/truth_table
  

• I run the tests with pytest-watcher

  uv run pytest-watcher . --now
  

  the terminal is my friend, and shows

  rootdir: .../pumping_python/truth_table
  configfile: pyproject.toml
  collected 12 items
  
  tests/test_binary.py ........                      [ 66%]
  tests/test_nullary_unary.py ....                   [100%]
  
  ================== 12 passed in G.HIs ===================
  

• I hold ctrl (Windows) or option (MacOS) on the keyboard, then click on tests/test_binary.py with the mouse to open it

• Up to this point I have tested

  • contradiction which always returns False

  • logical_conjunction aka and which returns first_input and second_input

  • project_second which always returns second_input

  • converse_non_implication which returns not first_input and second_input

  • negate_first which always returns not first_input

  • logical_nand which returns not (first_input and second_input)

  • tautology which always returns True

  • logical_disjunction which returns first_input or second_input

---

test_exclusive_disjunction

The truth table for exclusive_disjunction is

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

---

RED: make it fail

---

I add a test for exclusive_disjunction with an assertion for the case when the first input is True and the second input is True, to test_binary.py

first input	second input	return
True	True	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))


# Exceptions seen

the terminal is my friend, and shows AttributeError

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

because truth_table.py does not have anything in it with that name.

---

GREEN: make it pass

---

I add exclusive_disjunction to truth_table.py

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


def exclusive_disjunction(first_input, second_input):
    return False

the test passes. exclusive_disjunction returns False, if the first input is True and the second input is True.

---

REFACTOR: make it better

---

• I add an assertion for the next case, which is when the first input is True and the second input is False, to test_exclusive_disjunction in test_binary.py

  first input	second input	return
  True	False	True

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

  the terminal is my friend, and shows AssertionError

  AssertionError: False is not true
  

  because the function returns False and the assertion expects True.

• I add an if statement to the exclusive_disjunction function in truth_table.py

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

  the test passes. exclusive_disjunction returns

  • True, if the second input is False

  • False, if the above condition is NOT met

• I add an assertion for the third case, which is when the first input is False and the second input is True, to test_binary.py

  first input	second input	return
  False	True	True

      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))
  
  
  # Exceptions seen
  

  the terminal is my friend, and shows AssertionError

  AssertionError: False is not true
  

  because this happens when if second_input == False: runs, Python checks if second_input is equal to False

  • if second_input is NOT equal to False, it leaves the if statement and continues to run the rest of the function - return False and leaves the function since the return statement is the last thing to run in a function

  • second_input is True in this case, which raises AssertionError since the function returns False and the assertion expects True

• I add an if statement to exclusive_disjunction in truth_table.py

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

  the test passes because this happens when exclusive_disjunction is called - it runs if first_input == False:, where Python checks if first_input is equal to False

  • if first_input is NOT equal to False, it leaves the if statement and continues to the next if statement in the function - if second_input == False:.which checks if second_input is equal to False

    • if second_input is NOT equal to False, it leaves the if statement and continues to run the rest of the function - return False and leaves the function since the return statement is the last thing to run in a function

    • if second_input is equal to False, it goes to the next line - ``return True `` and leaves the function since the return statement is the last thing to run in a function

  • if first_input is equal to False, it goes to the next line - ``return True `` and leaves the function since the return statement is the last thing to run in a function

  • so far this is the same as the first three cases of logical_nand

• I add an assertion for the last case, which is when the first input is False and the second input is False to test_exclusive_disjunction, in test_binary.py

  first input	second input	return
  False	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))
  
  
  # Exceptions seen
  

  the terminal is my friend, and shows AssertionError

  AssertionError: True is not false
  

  because this happens when exclusive_disjunction is called - it runs if first_input == False:, where Python checks if first_input is equal to False

  • if first_input is equal to False, it goes to the next line - return True

  • if first_input is NOT equal to False, it leaves the if statement and continues to the next if statement at the same indentation level in the function - if second_input == False:, which checks if second_input is equal to False

    • if second_input is NOT equal to False, it leaves the if statement and continues to run the rest of the function - return False

    • if second_input is equal to False, it goes to the next line - return True

    • second_input is False in this case, which raises AssertionError since the function returns True and the assertion expects False

• I add an if statement for this case, to the one for when the first input is False in the exclusive_disjunction function in truth_table.py

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

  the test passes because this happens when exclusive_disjunction is called - it runs if first_input == False:, where Python checks if first_input is equal to False

  • if first_input is NOT equal to False, it leaves the if statement and continues to the next if statement at the same indentation level in the function - if second_input == False:, which checks if second_input is equal to False

    • if second_input is NOT equal to False, it leaves the if statement and continues to run the rest of the function - return False

    • if second_input is equal to False, it goes to the next line - return True

  • if first_input is equal to False, it goes to the next line - if second_input == False, which checks if if second_input is equal to False

    • if second_input is NOT equal to False, it leaves the if statement and continues to the next line for if first_input == False: - return True

    • if second_input is equal to False, it goes to the next line - return False

• there are two cases where exclusive_disjunction returns False and two cases where it returns True. I add an if statement for the other case where it returns True, to make it clearer

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

  the test is still green because this happens when exclusive_disjunction is called - it runs if first_input == False:, where Python checks if first_input is equal to False

  • if first_input is NOT equal to False, it leaves the if statement and continues to the next if statement at the same indentation level in the function - if first_input == True:, which checks if first_input is equal to True

    • if first_input is NOT equal to True, it leaves the if statement and continues to run the rest of the function - return False and leaves the function since the return statement is the last thing to run in a function

    • if first_input is equal to True, it goes to the next line - if second_input == False:, which checks if second_input is equal to False

      • if second_input is NOT equal to False, it leaves the if statement and continues to run the rest of the function - return False and leaves the function since the return statement is the last thing to run in a function

      • if second_input is equal to False, it runs the next line - ``return True `` and leaves the function since the return statement is the last thing to run in a function

  • if first_input is equal to False, it goes to the next line - if second_input == False, which checks if second_input is equal to False

    • if second_input is NOT equal to False, it leaves the if statement and continues to the next line for if first_input == False: - ``return True `` and leaves the function since the return statement is the last thing to run in a function

    • if second_input is equal to False, it runs the next line - return False and leaves the function since the return statement is the last thing to run in a function

• I add the bool built-in function

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

  still green.

• I use Logical Negation (NOT) to write three of the if statements in terms of True

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

  green.

• I remove == True

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

  still green.

• I remove bool

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

  the test is still green, because

  • when if something == False: runs, Python checks if something is equal to False. I can assume the following substitutions

    • if the value of something is False

      if something           == False
      if bool(something    ) == False
      if bool(False        ) == False
      if False               == False
      if True                == True  # use equality
      if True                         # remove '== True'
      if not False                    # change to terms of False
      if not something
      

    • if the value of something is True

      if something           == False
      if bool(something    ) == False
      if bool(True         ) == False
      if True                == False
      if False               == True  # use equality
      if False                        # remove '== True'
      if not True                     # change to terms of True
      if not something
      

  • when if something == True: runs, Python checks if (something) is equal to True. I can assume the following substitutions

    • if the value of something is False

      if something           == True
      if bool(something    ) == True
      if bool(False        ) == True
      if False               == True
      if not True            == True  # change to terms of True
      if not True                     # remove '==True'
      if False
      if something
      

    • if the value of something is True

      if something           == True
      if bool(something    ) == True
      if bool(True         ) == True
      if True                == True  # remove '==True'
      if True
      if something
      

  • if bool(something) == False is the same as if bool(not something) == True is the same as if bool(not something) is the same as if not something.

  • if bool(something) == True is the same as if bool(something) is the same as if something.

• I move the if statements to put them together

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

  still green.

• I add if statements for the other two cases to make it clearer

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

  green.

• I use Logical Conjunction (AND) to write the if statements for all the cases

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

  still green, because I can put two if statements together when one is indented under the other

  if something:
      if something_else:
  

  can also be written as

  if something and something_else:
  

• I move the first if statement to the bottom to be with the other statement that returns the same thing (False)

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

  the test is still green.

• I use Logical Disjunction (OR) to put the if statements that return the same thing together

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

  still green, because I can put two if statements together when they both return the same thing and are at the same indentation level

  if something:
      return this
  if something_else:
      return this
  

  can also be written as

  if something or something_else:
      return this
  

• I change the second if statement to an else clause

      if (
          (not first_input and second_input)
          or
          (first_input and not second_input)
      ):
          return True
      # if not first_input and not second_input:
      #     return False
      # if first_input and second_input:
      # if (
      #     (first_input and second_input)
      #     or
      #     (not first_input and not second_input)
      # ):
      else:
          return False
  

  green.

• I add a conditional expression

      # if (
      #     (not first_input and second_input)
      #     or
      #     (first_input and not second_input)
      # ):
      #     return True
      # if not first_input and not second_input:
      #     return False
      # if first_input and second_input:
      # if (
      #     (first_input and second_input)
      #     or
      #     (not first_input and not second_input)
      # ):
      # else:
      #     return False
      return True if (
          (not first_input and second_input)
          or
          (first_input and not second_input)
      ) else False
  

  still green.

• I remove True if and else False to make it simpler

      # if (
      #     (not first_input and second_input)
      #     or
      #     (first_input and not second_input)
      # ):
      #     return True
      # if not first_input and not second_input:
      #     return False
      # if first_input and second_input:
      # if (
      #     (first_input and second_input)
      #     or
      #     (not first_input and not second_input)
      # ):
      # else:
      #     return False
      # return True if (
      return (
          (not first_input and second_input)
          or
          (first_input and not second_input)
      # ) else False
      )
  

  the test is still green.

• exclusive_disjunction returns ((not first_input and second_input) or (first_input and not second_input))

  • not first_input and second_input is the Logical Conjunction (AND) of the Logical Negation (NOT) of the first input, and the second input

    logical_conjunction(
        logical_negation(first_input),
        second_input
    )
    

  • not first_input is the Logical Negation (NOT) of first_input

    • if the first input is True, this part of the statement is False

    • if the first input is False, this part of the statement is True

  • first_input and not second_input is the Logical Conjunction (AND) of the first input, and the Logical Negation (NOT) of the second input

    logical_conjunction(
        first_input,
        logical_negation(second_input)
    )
    

  • not second_input is the Logical Negation (NOT) of second_input

    • if the second input is True, this part of the statement is False

    • if the second input is False, this part of the statement is True

  • ((not first_input and second_input) or (first_input and not second_input)) can be thought of as the Logical Disjunction (OR) of the Logical Conjunction (AND) of the Logical Negation (NOT) of the first input, and the second input, and the Logical Conjunction (AND) of the first input, and the Logical Negation (NOT) of the second input. Very confusing when written in English

    logical_disjunction(
        logical_conjunction(
            logical_negation(first_input),
            second_input
        ),
        logical_conjunction(
            first_input,
            logical_negation(second_input)
        )
    )
    

    it can be thought of as the Logical Disjunction (OR) of the Converse Non-Implication of the first input, and the second input, and the Logical Conjunction (AND) of the first input, and the Logical Negation (NOT) of the second input

    logical_disjunction(
        converse_non_implication(
            first_input,
            second_input
        ),
        logical_conjunction(
            first_input,
            logical_negation(second_input)
        )
    )
    

    because converse_non_implication returns not first_input and second_input

  This means that in the four cases

  • if the first input is True and the second input is True, exclusive_disjunction returns

    (not first and second) or (first and not second)
    (not True  and True  ) or (True  and not True  )
    (False     and True  ) or (True  and False     )
     False                 or  False
     False                 # logical_disjunction(False, False)
    

  • if the first input is True and the second input is False, exclusive_disjunction returns

    (not first and second) or (first and not second)
    (not True  and False ) or (True  and not False )
    (False     and False ) or (True  and True      )
     False                 or  True
     True                  # logical_disjunction(False, True)
    

  • if the first input is False and the second input is True, exclusive_disjunction returns

    (not first and second) or (first and not second)
    (not False and True  ) or (False and not True  )
    (True      and True  ) or (False and False     )
     True                  or  False
     True                  # logical_disjunction(True, False)
    

  • if the first input is False and the second input is False, exclusive_disjunction returns

    (not first and second) or (first and not second)
    (not False and False ) or (False and not False )
    (True      and False ) or (False and True      )
     False                 or  False
     False                 # logical_disjunction(False, False)
    

  first	second	not first	not second	((not first) and second)	(first and (not second))	((not first) and second) or (first and (not second))
  True	True	False	False	False	False	False
  True	False	False	True	False	True	True
  False	True	True	False	True	False	True
  False	False	True	True	False	False	False

  I add a return statement to show this

      # return True if (
      return logical_disjunction(
          converse_non_implication(
              first_input, second_input
          ),
          logical_conjunction(
              first_input,
              logical_negation(second_input)
          )
      )
      return (
          (not first_input and second_input)
          or
          (first_input and not second_input)
      # ) else False
      )
  

  the test is still green.

• exclusive_disjunction returns False when the two inputs are equal, it returns True when the two inputs are NOT equal. I add an if statement to show this

      # return True if (
      if first_input == second_input:
          return False
      else:
          return True
      return logical_disjunction(
          converse_non_implication(
              first_input, second_input
          ),
          logical_conjunction(
              first_input,
              logical_negation(second_input)
          )
      )
      return (
          (not first_input and second_input)
          or
          (first_input and not second_input)
      # ) else False
      )
  

  green.

• I change the else clause to the Logical Negation (NOT) of the new if statement so I can write a conditional expression

      # return True if (
      if first_input == second_input:
          return False
      # else:
      if not (first_input == second_input):
          return True
      return logical_disjunction(
          converse_non_implication(
              first_input, second_input
          ),
          logical_conjunction(
              first_input,
              logical_negation(second_input)
          )
      )
      return (
          (not first_input and second_input)
          or
          (first_input and not second_input)
      # ) else False
      )
  

  still green.

• I add a conditional expression

      # return True if (
      # if first_input == second_input:
      #     return False
      # else:
      # if not (first_input == second_input):
      #     return True
      return (
          True if
          not (first_input == second_input)
          else False
      )
      return logical_disjunction(
          converse_non_implication(
              first_input, second_input
          ),
          logical_conjunction(
              first_input,
              logical_negation(second_input)
          )
      )
      return (
          (not first_input and second_input)
          or
          (first_input and not second_input)
      # ) else False
      )
  

  the test is still green.

• I remove True if and else False to make the statement simpler

      # return True if (
      # if first_input == second_input:
      #     return False
      # else:
      # if not (first_input == second_input):
      #     return True
      return (
          # True if
          not (first_input == second_input)
          # else False
      )
      return logical_disjunction(
          converse_non_implication(
              first_input, second_input
          ),
          logical_conjunction(
              first_input,
              logical_negation(second_input)
          )
      )
      return (
          (not first_input and second_input)
          or
          (first_input and not second_input)
      # ) else False
      )
  

  still green.

• I can also write the conditional expression with the NOT equal symbol (!=) (exclamation mark and equal symbol !+= on the keyboard)

      # return True if (
      # if first_input == second_input:
      #     return False
      # else:
      # if not (first_input == second_input):
      #     return True
      return first_input != second_input
      return (
          # True if
          not (first_input == second_input)
          # else False
      )
      return logical_disjunction(
          converse_non_implication(
              first_input, second_input
          ),
          logical_conjunction(
              first_input,
              logical_negation(second_input)
          )
      )
      return (
          (not first_input and second_input)
          or
          (first_input and not second_input)
      # ) else False
      )
  

  green.

• I remove the commented lines

  def exclusive_disjunction(first_input, second_input):
      return first_input != second_input
      return not (first_input == second_input)
      return logical_disjunction(
          converse_non_implication(
              first_input, second_input
          ),
          logical_conjunction(
              first_input,
              logical_negation(second_input)
          )
      )
      return (
          (not first_input and second_input)
          or
          (first_input and not second_input)
      )
  

  I can use any of these `return statements`_. The first return statement is the only one that runs in this case, because the return statement is the last thing to run in a function.

• I add a git commit message in another terminal

  git commit -am 'add exclusive_disjunction'
  

Exclusive Disjunction returns

• True, if first_input is NOT EQUAL to second_input

• False, if first_input is EQUAL the second_input

• first_input != second_input - which reads as first_input is NOT equal to second_input

• not (first_input == second_input) - which can be read as the Logical Negation of the Logical Equality of the first input and the second input

• (not first_input and second_input) or (first_input and not second_input) which is the Logical Disjunction of the Logical Conjunction of the Logical Negation of the first input, and the second input, and the Logical Conjunction of the first input and the Logical Negation of the second input. Wow! That’s a lot.

• All of the above statements mean the same thing.

Exclusive Disjunction is also known as Exclusive OR or XOR. Would “Logical Inequality” be a better name?

---

examples of Exclusive Disjunction

---

• two light switches for one bulb, if the inputs are

  • is switch A on?

  • is switch B on?

  switch A?	switch B?	bulb on?
  on	on	no
  on	off	yes
  off	on	yes
  off	off	no

• magnets attract, if the inputs are

  • what is the direction of magnet A?

  • what is the direction of magnet B?

  magnet A?	magnet B?	attract?
  north	north	no
  north	south	yes
  south	north	yes
  south	south	no

• a coin toss, if the inputs are

  • my choice

  • your choice

  my choice	your choice	there is a winner
  heads	heads	no
  heads	tails	yes
  tails	heads	yes
  tails	tails	no

• two people meet at a door that can only take one person at a time, if the inputs are

  • I go

  • You go

  I go	you go	we both go
  go	go	no
  go	stop	yes
  stop	go	yes
  stop	stop	no

• A broken vending machine, if the inputs are

  • did I put money in the machine?

  • did I get what I picked?

  I paid	I got what I want	machine is broken
  yes	yes	no
  yes	no	yes
  no	yes	yes
  no	no	no

  should I complain when I did not pay and I got what I want?

---

test_material_non_implication

The truth table for material_non_implication is

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

---

RED: make it fail

---

• I go back to the terminal where the tests are running

• I add a test for material_non_implication with an assertion for when the first input is True and the second input is True, to test_binary.py

  first input	second input	return
  True	True	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)
          )
  
  
  # Exceptions seen
  

  the terminal is my friend, and shows AttributeError

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

  material_non_implication is not in truth_table.py

---

GREEN: make it pass

---

I add material_non_implication to truth_table.py

def exclusive_disjunction(first_input, second_input):
    return first_input != second_input
    return not (first_input == second_input)
    return logical_disjunction(
        converse_non_implication(
            first_input, second_input
        ),
        logical_conjunction(
            first_input,
            logical_negation(second_input)
        )
    )
    return (
        (not first_input and second_input)
        or
        (first_input and not second_input)
    )


def material_non_implication(first_input, second_input):
    return False

the test passes. material_non_implication returns False, if the first input is True and the second input is True.

---

REFACTOR: make it better

---

• I add an assertion for the second case, which is when the first input is True and the second input is False to test_material_non_implication in test_binary.py

  first input	second input	return
  True	False	True

      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)
          )
  
  
  # Exceptions seen
  

  the terminal is my friend, and shows AssertionError

  AssertionError: False is not true
  

  because the function returns False and the assertion expects True.

• I add an if statement to material_non_implication in truth_table.py

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

  the test passes. When material_non_implication is called, it runs if second_input == False:

  • if second_input is NOT equal to False, it leaves the if statement then runs return False

  • if second_input is equal to False, it runs return True

• I add an assertion for the third case to test_material_non_implication, for when the first input is False and the second input is True, in test_binary.py

  first input	second input	return
  False	True	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)
          )
  
  
  # Exceptions seen
  

  the test is still green.

• I add an assertion for the fourth case, which is when the first input is False and the second input is False

  first input	second input	return
  False	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)
          )
  
  
  # Exceptions seen
  

  the terminal is my friend, and shows AssertionError

  AssertionError: True is not false
  

  because when material_non_implication is called, it runs if second_input == False:

  • if second_input is NOT equal to False, it leaves the if statement then runs return False

  • if second_input is equal to False, it runs return True

  • second_input is False in this case, which raises AssertionError since the assertion expects False and the function returns True

• I add an if statement for the one case that returns True to the material_non_implication function in truth_table.py

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

  the test passes because when material_non_implication is called, it runs if first_input == True:

  • if first_input is NOT equal to True, it leaves the if statement then runs return False

  • if first_input is equal to True, it runs if second_input == False:

    • if second_input is NOT equal to False, it leaves if first_input == True: then runs the next line in the function - return False

    • if second_input is equal to False, it runs return True

• I use the bool built-in function

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

  the test is still green.

• I use Logical Negation (NOT) to write the second if statement in terms of True

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

  still green.

• I remove == True

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

  green.

• I remove bool

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

  still green, because

  • if bool(something) == True is the same as if bool(something) is the same as if something.

  • if bool(something) == False is the same as if bool(not something) == True is the same as if bool(not something) is the same as if not something.

• I use Logical Conjunction (AND) to put the two if statements together

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

  the test is still green, because I can put two if statements together when one is indented under the other

  if something:
      if something_else:
  

  can also be written as

  if something and something_else:
  

• I add a conditional expression

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

  still green.

• I remove True if and else False to make the statement simpler

      return (
          # True if
          first_input and not second_input
          # else False
      )
  

  green.

• material_non_implication returns first_input and not second_input

  • not second_input is the Logical Negation (NOT) of second_input

    • if the second input is True, this part of the statement is False

    • if the second input is False, this part of the statement is True

  • first_input and not second_input is the Logical Conjunction (AND) of the first input and the Logical Negation (NOT) of the second input

    logical_conjunction(
        first_input,
        logical_negation(second_input)
    )
    

  this means that in the four cases

  • if the first input is True and the second input is True, material_non_implication returns

    first_input and not second_input
    True        and not True
    True        and False
    False       # logical_conjunction(True, False)
    

  • if the first input is True and the second input is False, material_non_implication returns

    first_input and not second_input
    True        and not False
    True        and True
    True        # logical_conjunction(True, True)
    

  • if the first input is False and the second input is True, material_non_implication returns

    first_input and not second_input
    False       and not True
    False       and False
    False       # logical_conjunction(False, False)
    

  • if the first input is False and the second input is False, material_non_implication returns

    first_input and not second_input
    False       and not False
    False       and True
    False       # logical_conjunction(False, True)
    

  first	second	not second	(first and not second)
  True	True	False	False
  True	False	True	True
  False	True	False	False
  False	False	True	False

  I add a return statement to show this

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

  still green.

• I remove the comments

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

  I can use either of these `return statements`_. The first return statement is the only one that runs in this case, because the return statement is the last thing to run in a function.

• I add a git commit message in another terminal

  git commit -am 'add material_non_implication'
  

Material Non-Implication

• returns first_input and not second_input which is the Logical Conjunction of the first input and the Logical Negation of the second input

• returns True, only if the first input is True and the second input is False

• is the Logical Negation of Material/Logical Implication which returns False only if the first input is True and the second input is False

• can be thought of as a claim that does not deliver

---

examples of Material Non-Implication

---

• A broken promise, if the inputs are

  • did I make a promise?

  • did I do something?

  I promised	I did something	broken promise
  yes	yes	no
  yes	no	yes
  no	yes	no
  no	no	no

• A false alarm, if the inputs are

  • did alarm ring?

  • was there a bad event?

  alarm rang	bad event	false alarm
  yes	yes	no
  yes	no	yes
  no	yes	no (alarm is broken)
  no	no	no

• the boy who cried wolf, if the inputs are

  • did the boy cry?

  • was there a wolf?

  boy cried	wolf	false claim
  yes	yes	no
  yes	no	yes
  no	yes	no
  no	no	no

---

more about Exclusive Disjunction

---

Since I know material_non_implication I can think of Exclusive Disjunction which returns (not first_input and second_input) or (first_input and not second_input) as

return logical_disjunction(
    converse_non_implication(
        first_input, second_input
    ),
    material_non_implication(
        first_input, second_input
    )
)

because

logical_disjunction(first_input, second_input)

first_input              == (not first_input and second_input)
converse_non_implication == (not first_input and second_input)

second_input             == (first_input and not second_input)
material_non_implication == (first_input and not second_input)

• logical_disjunction returns first_input or second_input

  • first_input in this case is (not first_input and second_input)

  • second_input in this case is (first_input and not second_input)

• converse_non_implication returns not first_input and second_input

• material_non_implication returns first_input and not second_input

• I change the return statement in the exclusive_disjunction function in truth_table.py

    def exclusive_disjunction(first_input, second_input):
        # return first_input != second_input
        # return not (first_input == second_input)
        return logical_disjunction(
            converse_non_implication(
                first_input, second_input
            ),
            # logical_conjunction(
            material_non_implication(
                first_input, second_input
                # logical_negation(second_input)
            )
        )
        return (
            (not first_input and second_input)
            or
            (first_input and not second_input)
        )
  

  the test is still green.

• I put the first two `return statements`_ back, then remove the commented lines

  def exclusive_disjunction(first_input, second_input):
      return first_input != second_input
      return not (first_input == second_input)
      return logical_disjunction(
          converse_non_implication(
              first_input, second_input
          ),
          material_non_implication(
              first_input, second_input
          )
      )
      return (
          (not first_input and second_input)
          or
          (first_input and not second_input)
      )
  
  
  def material_non_implication(first_input, second_input):
      return logical_conjunction(
          first_input,
          logical_negation(second_input)
      )
      return first_input and not second_input
  

• I add a git commit message in the other terminal

  git commit -am 'refactor exclusive_disjunction'
  

---

test_project_first

The truth table for project_first is

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

---

RED: make it fail

---

• I go back to the terminal where the tests are running

• I add a test for project_first with an assertion for when the first input is True and the second input is True, in test_binary.py

  first input	second input	return
  True	True	True

      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))
  
  
  # Exceptions seen
  

  the terminal is my friend, and shows AttributeError

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

  there is nothing named project_first in truth_table.py

---

GREEN: make it pass

---

I add a function for project_first to truth_table.py

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


def project_first(first_input, second_input):
    return True

the test passes. project_first returns True, if the first input is True and the second input is True.

---

REFACTOR: make it better

---

• I add an assertion for the second case, which is when the first input is True and the second input is False, to test_project_first in test_binary.py

  first input	second input	return
  True	False	True

      def test_project_first(self):
          project_first = src.truth_table.project_first
          self.assertTrue(project_first(True, True))
          self.assertTrue(project_first(True, False))
  
  
  # Exceptions seen
  

  the test is still green. project_first returns

  • True, if the first input is True and the second input is False

  • True, if the first input is True and the second input is True

  • True, if the first input is True

• on to the next case, which is when the first input is False and the second input is True

  first input	second input	return
  False	True	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))
  
  
  # Exceptions seen
  

  the terminal is my friend, and shows AssertionError

  AssertionError: True is not false
  

  because the function returns True and the assertion expects False.

• I add an if statement for this case to the project_first function in truth_table.py

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

  the test passes because when project_first is called, it runs if first_input == False:

  • if first_input is NOT equal to False, it leaves the if statement then runs return True

  • if first_input is equal to False, it runs return False

• I add an assertion for the last case, which is when the first input is False and the second input is False, to test_project_first in test_binary.py

  first input	second input	return
  False	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))
  
  
  # Exceptions seen
  

  the test is still green.

• I add the bool built-in function to the if statement in the project_first function in truth_table.py

  def project_first(first_input, second_input):
      # if first_input == False:
      if bool(first_input) == False:
          return False
      return True
  

  still green.

• I use Logical Negation (NOT) to write it in terms of True

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

  green.

• I remove == True

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

  still green.

• I remove bool

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

  the test is still green, because if bool(something) == False is the same as if bool(not something) == True is the same as if bool(not something) is the same as if not something.

• I add an else clause to make it clearer

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

  still green.

• I use Logical Negation (NOT) for the else clause

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

  green.

• I remove the nots because they cancel out

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

  still green.

• I add a conditional expression

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

  the test is still green.

• I remove True if and else False

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

  still green.

• I remove the other statements

  def project_first(first_input, second_input):
      return first_input
  

• I add a git commit message in another terminal

  git commit -am 'add project_first'
  

Project First always returns the first input it does not care about the second input, like Project Second which always returns the second input and does not care about the first input.

---

examples of Project First

---

• did the event happen, if the inputs are

  • did the event happen?

  • did we get a notification about it?

  event	notification	event happened
  yes	yes	yes
  yes	no	yes
  no	yes	no (notification is broken)
  no	no	no

  “if a tree falls in the forest, does it make a sound?”

• able to login with or without Multi Factor Authentication, if the inputs are

  • did user provide the right password?

  • does user have MFA?

  right password	right MFA code	log in
  yes	yes	yes
  yes	no	yes
  no	yes	no (how did user get the MFA code?)
  no	no	no

• my actions, if the inputs are

  • what I want to do?

  • what you think I should do?

  what I want	your thoughts	my actions
  yes	yes	yes
  yes	no	yes
  no	yes	no
  no	no	no

• autocorrect, if the inputs are

  • autocorrect suggests a word

  • I write what I want

  autocorrect	what I want	what I get
  yes	yes	yes
  yes	no	yes
  no	yes	no
  no	no	no

---

test_converse_implication

The truth table for converse_implication is

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

---

RED: make it fail

---

• I go back to the terminal where the tests are running

• I add a test for converse_implication with an assertion for when the first input is True and the second input is True, to test_binary.py

  first input	second input	return
  True	True	True

      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)
          )
  
  
  # Exceptions seen
  

  the terminal is my friend, and shows AttributeError

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

  because truth_table.py does not have anything named converse_implication in it.

---

GREEN: make it pass

---

I add a function for converse_implication to truth_table.py

def project_first(first_input, second_input):
    return first_input


def converse_implication(first_input, second_input):
    return True

the test passes. converse_implication returns True, if the first input is True and the second input is True.

---

REFACTOR: make it better

---

• I add an assertion for the second case, which is when the first input is True and the second input is False to test_converse_implication in test_binary.py

  first input	second input	return
  True	False	True

      def test_converse_implication(self):
          converse_implication = (
              src.truth_table.converse_implication
          )
          self.assertTrue(
              converse_implication(True, True)
          )
          self.assertTrue(
              converse_implication(True, False)
          )
  
  
  # Exceptions seen
  

  the test is still green. converse_implication returns True

  • if the first input is True and the second input is False

  • if the first input is True and the second input is True

  • if the first input is True

• time for the next case, which is when the first input is False and the second input is True

      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)
          )
  
  
  # Exceptions seen
  

  the terminal is my friend, and shows AssertionError

  AssertionError: True is not false
  

  because the converse_implication function returns True and the assertion expects False.

• I add an if statement to converse_implication in truth_table.py

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

  the test passes because when converse_implication is called, it runs if first_input == False:

  • if first_input is NOT equal to False, it leaves the if statement then runs return True

  • if first_input is equal to False, it runs return False

• I add an assertion for the last case, which is when the first input is False and the second input is False, to test_converse_implication in test_binary.py

  first input	second input	return
  False	False	True

      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)
          )
  
  
  # Exceptions seen
  

  the terminal is my friend, and shows AssertionError

  AssertionError: False is not true
  

  because when converse_implication is called, it runs if first_input == False:

  • if first_input is NOT equal to False, it leaves the if statement then runs return True

  • if first_input is equal to False, it runs return False

  • first_input is False in this case, which raises AssertionError since the assertion expects True and the function returns False

• I add an if statement for the only case that returns True

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

  the test passes because when converse_implication is called, it runs if first_input == False:

  • if first_input is NOT equal to False, it leaves the if statement then runs return True

  • if first_input is equal to False, it runs if second_input == True:

    • if second_input is NOT equal to True, it leaves if first_input == False: and runs return True

    • if second_input is equal to True, it runs return False

• I add the bool built-in function

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

  the test is still green.

• I use Logical Negation (NOT) to write the first if statement in terms of True

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

  still green.

• I remove == True

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

  green.

• I remove bool

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

  still green, because

  • if bool(something) == False is the same as if bool(not something) == True is the same as if bool(not something) is the same as if not something.

  • if bool(something) == True is the same as if bool(something) is the same as if something.

• I use Logical Conjunction (AND) to put the two if statements together

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

  the test is still green, because I can put two if statements together when one is indented under the other

  if something:
      if something_else:
  

  can also be written as

  if something and something_else:
  

• I add an else clause to make it clearer

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

  still green.

• I use the Logical Negation (NOT) of the if statement for the else clause

      if not first_input and second_input:
          return False
      # else:
      if not (not first_input and second_input):
          return True
  

  green.

• I “multiply” the not by every symbol in the parentheses

      if not first_input and second_input:
          return False
      # else:
      # if not (not first_input and second_input):
      if (
          (not not first_input)
          (not and)
          (not second_input)
      ):
          return True
  

  the terminal is my friend, and shows SyntaxError

  SyntaxError: invalid syntax
  

  I cannot negate and this way

• I change not and to or

      if not first_input and second_input:
          return False
      # else:
      # if not (not first_input and second_input):
      if (
          (not not first_input)
          # (not and)
          or
          (not second_input)
      ):
          return True
  

  the test is green again.

• I remove not not

      if not first_input and second_input:
          return False
      # else:
      # if not (not first_input and second_input):
      if (
          # (not not first_input)
          first_input
          # (not and)
          or
          (not second_input)
      ):
          return True
  

  the test is still green because two nots cancel out.

• I add a conditional expression

      # if not first_input and second_input:
      #     return False
      # else:
      # if not (not first_input and second_input):
      # if (
          # (not not first_input)
          # first_input
          # (not and)
          # or
          # (not second_input)
      # ):
          # return True
      return (
          True if
          first_input or not second_input
          else False
      )
  

  still green.

• I remove True if and else False

      # if not first_input and second_input:
      #     return False
      # else:
      # if not (not first_input and second_input):
      # if (
          # (not not first_input)
          # first_input
          # (not and)
          # or
          # (not second_input)
      # ):
          # return True
      return (
          # True if
          first_input or not second_input
          # else False
      )
  

  green.

• converse_implication returns first_input or not second_input

  • not second_input is the Logical Negation (NOT) of second_input

    • if the second input is True, this part of the statement is False

    • if the second input is False, this part of the statement is True

  • first_input or not second_input is the Logical Disjunction (OR) of the first input and the Logical Negation (NOT) of the second input

    logical_disjunction(
        first_input,
        logical_negation(second_input)
    )
    

  this means that in the four cases

  • if the first input is True and the second input is True, converse_implication returns

    first_input or not second_input
    True        or not True
    True        or False
    True        # logical_disjunction(True, False)
    

  • if the first input is True and the second input is False, converse_implication returns

    first_input or not second_input
    True        or not False
    True        or True
    True        # logical_disjunction(True, True)
    

  • if the first input is False and the second input is True, converse_implication returns

    first_input or not second_input
    False       or not True
    False       or False
    False       # logical_disjunction(False, False)
    

  • if the first input is False and the second input is False, converse_implication returns

    first_input or not second_input
    False       or not False
    False       or True
    True        # logical_disjunction(False, True)
    

  first	second	not second	(first or not second)
  True	True	False	True
  True	False	True	True
  False	True	False	False
  False	False	True	True

  I add a return statement to show this

  def converse_implication(first_input, second_input):
      # if first_input == False:
      # if bool(first_input) == False:
      # if bool(not first_input) == True:
      # if bool(not first_input):
      # if not first_input:
          # if second_input == True:
          # if bool(second_input) == True:
          # if bool(second_input):
          # if second_input:
      # if not first_input and second_input:
      #     return False
      # else:
      # if not (not first_input and second_input):
      # if (
          # (not not first_input)
          # first_input
          # (not and)
          # or
          # (not second_input)
      # ):
          # return True
      return logical_disjunction(
          first_input,
          logical_negation(second_input)
      )
      return (
          # True if
          first_input or not second_input
          # else False
      )
  

  still green.

• I remove the comments

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

  I can use either of these `return statements`_. The first return statement is the only one that runs in this case, because the return statement is the last thing to run in a function.

• I add a git commit message in another terminal

  git commit -am 'add converse_implication'
  

Converse Implication returns

• first_input or not second_input

• False, only if the first input is False and the second input is True

• the Logical Disjunction of the first input and the Logical Negation of the second input

• It is the opposite of Converse Non-Implication which always returns not first_input and second_input or True, only if the first input is False and the second input is True

---

examples of Converse Implication

---

• I cannot get a table at a restaurant, if the inputs are

  • do I have a reservation?

  • is the place full?

  reservation	place is full	I get a table
  yes	yes	yes
  yes	no	yes
  no	yes	no
  no	no	yes

• sleep through alarm, if the inputs are

  • am I too deep in sleep to hear the alarm?

  • is the alarm ringing?

  too tired	alarm rings	I sleep
  yes	yes	yes
  yes	no	yes
  no	yes	no
  no	no	yes

• staying dry outside, if the inputs are

  • do I have an umbrella?

  • is it raining?

  umbrella?	raining?	dry
  yes	yes	yes
  yes	no	yes
  no	yes	no
  no	no	yes

---

close the project

• I close test_binary.py and truth_table.py

• I click in the terminal where the tests are running

• I use q on the keyboard to leave the tests. The terminal goes back to the command line.

• I change directory to the parent of truth_table

  cd ..
  

  the terminal shows

  .../pumping_python
  

  I am back in the pumping_python directory

---

review

Binary Operations take two inputs, each input can be True or False. If I name the first input first_input and the second input second_input, the tests show that

• Converse Implication

  • returns first_input or not second_input

  • returns False if first_input is False and second_input is True

  • is the Logical Negation (NOT) of Converse Non-Implication which returns True only if first_input is False and second_input is True

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

• Project First

  • always returns first_input

  • returns True only if first_input is True

  • is the Logical Negation (NOT) of Negate First which returns True only if first_input is False

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

• Material Non-Implication

  • returns first_input and not second_input

  • returns True only if first_input is True and second_input is False

  • is the Logical Negation (NOT) of Material/Logical Implication which returns False only if first_input is True and second_input is False

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

• Exclusive Disjunction

  • returns first_input != second_input

  • returns True only if first_input and second_input are NOT equal

  • is the Logical Negation (NOT) of Logical Equality which returns True only if first_input and second_input are equal

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

• Logical Disjunction

  • returns first_input or second_input

  • returns False only if first_input is False and second_input is False

  • is the Logical Negation (NOT) of Logical NOR which returns True only if first_input is False and second_input is False

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

• Tautology

  • always returns True

  • never returns False

  • is the Logical Negation (NOT) of contradiction which always returns False

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

• Logical NAND

  • returns not (first_input and second_input)

  • returns False only if first_input is True and second_input is True

  • is the Logical Negation (NOT) of Logical Conjunction (AND) which returns True only if first_input is True and second_input is True

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

• Negate First

  • always returns not first_input

  • returns True only if first_input is False

  • is the Logical Negation (NOT) of Project First which returns True only if first_input is True

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

• Converse Non-Implication

  • returns not first_input and second_input

  • returns True only if first_input is False and second_input is True

  • is the Logical Negation (NOT) of Converse Implication which returns False if first_input is False and second_input is True

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

• Project Second

  • always returns second_input

  • returns True only if second_input is True

  • is the Logical Negation (NOT) of Negate Second which returns True only if second_input is False

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

• Logical Conjunction returns

  • returns first_input and second_input

  • returns True only if first_input is True and second_input is True

  • is the Logical Negation (NOT) of Logical NAND which returns False only if first_input is True and second_input is True

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

• Contradiction

  • always returns False

  • never returns True

  • is the Logical Negation (NOT) of Tautology which always returns True

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

All the binary operations or conditions have been written with some combination of some or all of these three

• Logical Disjunction (OR)

• Logical Conjunction (AND)

• Logical Negation is (NOT)

return	True, True	True, False	False, True	False, False	name of 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

---

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 the last binary operations?

---

rate pumping python

If this has been a 7 star experience for you, please CLICK HERE to leave a 5 star review of pumping python. It helps other people get into the book too.

---

CLICK HERE to leave a 5 star review of pumping python, if this has been a 7 star experience for you