---

---

---

truth table: Binary Operations 3

---

requirements

Binary Operations 2

---

preview

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

truth_table/tests/test_binary.py

    def test_exclusive_disjunction(self):
        xor = src.truth_table.exclusive_disjunction
        self.assertFalse(xor(True, True))
        self.assertTrue(xor(True, False))
        self.assertTrue(xor(False, True))
        self.assertFalse(xor(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))

truth_table/tests/test_binary.py

    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

---

open the project

• I make sure I am in the pumping_python folder with pwd in the terminal

  pwd
  

  if the terminal does not show

  .../pumping_python
  

  I change directory to the pumping_python folder

• I change directory to the truth_table 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 open test_binary.py from the tests folder

• 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 tests/test_binary.py

first input	second input	return
True	True	False

        self.assertFalse(logical_disjunction(False, False))

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


# Exceptions seen

the terminal is my friend, and shows AttributeError

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

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

---

GREEN: make it pass

---

• I open __init__.py from the truth_table folder in the src folder

• I add exclusive_disjunction to src/truth_table/__init__.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.

  exclusive_disjunction(True , True ) -> False
  

---

REFACTOR: make it better

---

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

  first input	second input	return
  True	False	True

      def test_exclusive_disjunction(self):
          xor = src.truth_table.exclusive_disjunction
          self.assertFalse(xor(True, True))
          self.assertTrue(xor(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 src/truth_table/__init__.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

  exclusive_disjunction(True , False) -> True
  exclusive_disjunction(True , True ) -> False
  

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

  first input	second input	return
  False	True	True

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

  the terminal is my friend, and shows AssertionError

  AssertionError: False is not true
  

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

  • if second_input is NOT equal to False, it leaves the if statement and continues to run the rest of the function - return False then 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 src/truth_table/__init__.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 Python checks if first_input is equal to False when if first_input == False: runs

  • 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 then 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 then 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 then 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 if the first input is False and the second input is False to test_exclusive_disjunction, in tests/test_binary.py

  first input	second input	return
  False	False	False

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

  the terminal is my friend, and shows AssertionError

  AssertionError: True is not false
  

  because Python checks if first_input is equal to False when if first_input == False: runs

  • 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 src/truth_table/__init__.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 Python checks if first_input is equal to False when if first_input == False: runs

  • 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

      exclusive_disjunction(True , True ) -> False
      └── def exclusive_disjunction(first_input, second_input):
          ├── first_input  = True
          ├── second_input = True
          ├── if first_input == False:
          │       if second_input == False:
          │           return False
          │       return True
          ├── if second_input == False:
          │       return True
          └── return False
      

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

      exclusive_disjunction(True , False) -> True
      └── def exclusive_disjunction(first_input, second_input):
          ├── first_input  = True
          ├── second_input = False
          ├── if first_input == False:
          │       if second_input == False:
          │           return False
          │       return True
          └── if second_input == False:
              └── return True
              return False
      

  • 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

      exclusive_disjunction(False, True ) -> True
      └── def exclusive_disjunction(first_input, second_input):
          ├── first_input  = False
          ├── second_input = True
          └── if first_input == False:
              ├── if second_input == False:
              │       return False
              └── return True
              if second_input == False:
                  return True
              return False
      

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

      exclusive_disjunction(False, False) -> False
      └── def exclusive_disjunction(first_input, second_input):
          ├── first_input  = False
          ├── second_input = False
          └── if first_input == False:
              └── if second_input == False:
                  └── return False
                  return True
              if second_input == False:
                  return True
              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 Python checks if first_input is equal to False when if first_input == False: runs

  • 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 then 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 then 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 then 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 then 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 then 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 not bool(first_input) == True:
          # if second_input == False:
          # if bool(second_input) == False:
          if not bool(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 not bool(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 not bool(first_input) == True:
      if not bool(first_input):
          # if second_input == False:
          # if bool(second_input) == False:
          # if not bool(second_input) == True:
          if not bool(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 not bool(second_input) == True:
          if not bool(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 not bool(first_input) == True:
      # if not bool(first_input):
      if not first_input:
          # if second_input == False:
          # if bool(second_input) == False:
          # if not bool(second_input) == True:
          # if not bool(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 not bool(second_input) == True:
          # if not bool(second_input):
          if not second_input:
              return True
      return False
  

  the test is still green, because

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

    • if the value of something is False

      something = False
      
      if something       == False
      if bool(something) == False
      if bool(False    ) == False # use the value
      if False           == False # bool(False) returns False
      if True            == True  # write in terms of True
      if True                     # remove '== True'
      if not False                # not False == True
      if not something            # use the name for the value
      

    • if the value of something is True

      something = True
      
      if something       == False
      if bool(something) == False
      if bool(True     ) == False # use the value
      if True            == False # bool(True) returns True
      if False           == True  # write in terms of True
      if not True        == True  # write in terms of True
      if not True                 # remove '== True'
      if not something            # use the name for the value
      

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

    • if the value of something is False

      something = False
      
      if something       == True
      if bool(something) == True
      if bool(False    ) == True  # use the value
      if False           == True  # bool(False) returns False
      if not True        == True  # write in terms of True
      if not True                 # remove '== True'
      if False                    # not True == False
      if something                # use the name for the value
      

    • if the value of something is True

      something = True
      
      if something       == True
      if bool(something) == True
      if bool(True     ) == True # use the value
      if True            == True # bool(True) returns True
      if True                    # remove '== True'
      if something               # use the name for the value
      

  • if bool(something) == False is the same as if not bool(something) == True is the same as if not bool(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 not first_input:
          if not second_input:
              return False
          return True
      if first_input:
          if not second_input:
              return True
      return False
      # if first_input == False:
  

  still green.

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

  def exclusive_disjunction(first_input, 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 first_input == False:
  

  green.

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

  def exclusive_disjunction(first_input, second_input):
      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
      # 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 first_input == 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 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
      # if not first_input:
  

  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 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 first_input and second_input:
      #     return False
      # if not first_input and not second_input:
      if (
          (first_input and second_input)
          or
          (not first_input and not second_input)
      ):
          return False
      # if not first_input:
  

  still green, because I can put two if statements together if 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 first_input and second_input:
      #     return False
      # if not first_input and not 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 to exclusive_disjunction

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

  still green.

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

  def exclusive_disjunction(first_input, second_input):
      return (
          # True if
          (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. Confusing when written in English. If we use the function names we get

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

    Exclusive Disjunction can also 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

    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)
    

  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

  def exclusive_disjunction(first_input, second_input):
      return logical_disjunction(
          converse_non_implication(
              first_input, second_input
          ),
          logical_conjunction(
              first_input,
              logical_negation(second_input)
          )
      )
      return (
          # True if
          (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

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

  green.

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

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

  still green.

• I add a new conditional expression to exclusive_disjunction

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

  the test is still green.

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

  def exclusive_disjunction(first_input, second_input):
      return (
          # True if
          not (first_input == 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)

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

  green.

• I remove the commented lines and other statements from exclusive_disjunction

  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 the other 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 to 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.

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 if the first input is True and the second input is True, to tests/test_binary.py

  first input	second input	return
  True	True	False

          self.assertFalse(xor(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 src/truth_table/__init__.py.

---

GREEN: make it pass

---

I add material_non_implication to src/truth_table/__init__.py

    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.

material_non_implication(True , True ) -> False

---

REFACTOR: make it better

---

• I add an assertion for the second case, which is if the first input is True and the second input is False to test_material_non_implication in tests/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 src/truth_table/__init__.py

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

  the test passes 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

  material_non_implication(True , False) -> True
  material_non_implication(True , True ) -> False
  

• 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 tests/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.

  material_non_implication(False, True ) -> False
  material_non_implication(True , False) -> True
  material_non_implication(True , True ) -> False
  

• I add an assertion for the fourth case, which is if 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 src/truth_table/__init__.py

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

  the test passes.

  material_non_implication(False, False) -> False
  material_non_implication(False, True ) -> False
  material_non_implication(True , False) -> True
  material_non_implication(True , True ) -> False
  

  Python checks if first_input == True: when material_non_implication is called

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

    material_non_implication(False, False) -> False
    └── def material_non_implication(first_input, second_input):
        ├── first_input  = False
        ├── second_input = False
        ├── if first_input == True:
        │       if second_input == False:
        │           return True
        └── return False
    

    material_non_implication(False, True ) -> False
    └── def material_non_implication(first_input, second_input):
        ├── first_input  = False
        ├── second_input = True
        ├── if first_input == True:
        │       if second_input == False:
        │           return True
        └── 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

      material_non_implication(True , True ) -> False
      └── def material_non_implication(first_input, second_input):
          ├── first_input  = False
          ├── second_input = True
          └── if first_input == True:
          ┌───┴── if second_input == False:
          │           return True
          └── return False
      

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

      material_non_implication(True , True ) -> False
      └── def material_non_implication(first_input, second_input):
          ├── first_input  = False
          ├── second_input = True
          └── if first_input == True:
              └── if second_input == False:
                  └── return True
              return False
      

  • it only checks the second input if the first input is 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 not bool(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 not bool(second_input) == True:
          if not bool(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 not bool(second_input) == True:
          # if not bool(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 not bool(something) == True is the same as if not bool(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 not bool(second_input) == True:
          # if not bool(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 to material_non_implication

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

  still green.

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

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

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

  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 # logical_conjunction(True, False)
    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  # logical_conjunction(True, 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 # logical_conjunction(False, 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  # logical_conjunction(False, True)
    False
    

  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):
      return logical_conjunction(
          first_input,
          logical_negation(second_input)
      )
      return (
          # True if
          first_input and not second_input
          # else False
      )
  

  still green.

  material_non_implication(False, False) -> False
   └── logical_conjunction(False, True ) -> False
  
  material_non_implication(False, True ) -> False
   └── logical_conjunction(False, False) -> False
  
  material_non_implication(True , False) -> True
   └── logical_conjunction(True , True ) -> True
  
  material_non_implication(True , True ) -> False
   └── logical_conjunction(True , False) -> False
  

• I remove the commented lines and other statements from material_non_implication

  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 the other 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

I can also 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 returns first_input or second_input

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

• converse_non_implication returns not first_input and second_input

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

• material_non_implication returns first_input and not second_input

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)

• I change the return statement in the exclusive_disjunction function in src/truth_table/__init__.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)
          # )
          material_non_implication(
              first_input, 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 from exclusive_disjunction

  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
  

  still green.

• 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 if the first input is True and the second input is True, in tests/test_binary.py

  first input	second input	return
  True	True	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 src/truth_table/__init__.py

---

GREEN: make it pass

---

I add a function for project_first to src/truth_table/__init__.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.

project_first(True , True ) -> True

---

REFACTOR: make it better

---

• I add an assertion for the second case, which is if the first input is True and the second input is False, to test_project_first in tests/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

  project_first(True , False) -> True
  project_first(True , True ) -> True
  

• on to the next case, which is if 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 src/truth_table/__init__.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, Python checks if first_input == False:

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

    project_first(True , True ) -> True
    └── def project_first(first_input, second_input):
        ├── first_input  = True
        ├── second_input = True
        ├── if first_input == False:
        │      return False
        └── return True
    

    project_first(True , False) -> True
    └── def project_first(first_input, second_input):
        ├── first_input  = True
        ├── second_input = False
        ├── if first_input == False:
        │      return False
        └── return True
    

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

    project_first(False, False) -> False
    └── def project_first(first_input, second_input):
        ├── first_input  = False
        ├── second_input = False
        └── if first_input == False:
            └── return False
            return True
    

    project_first(False, True ) -> False
    └── def project_first(first_input, second_input):
        ├── first_input  = False
        ├── second_input = True
        └── if first_input == False:
            └── return False
            return True
    

• I add an assertion for the last case, which is if the first input is False and the second input is False, to test_project_first in tests/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.

  project_first(False, False) -> False
  project_first(False, True ) -> False
  project_first(True , False) -> True
  project_first(True , True ) -> True
  

• I add the bool built-in function to the if statement in the project_first function in src/truth_table/__init__.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 not bool(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 not bool(first_input) == True:
      if not bool(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 not bool(first_input) == True:
      # if not bool(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 not bool(something) == True is the same as if not bool(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 not bool(first_input) == True:
      # if not bool(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 not bool(first_input) == True:
      # if not bool(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 not bool(first_input) == True:
      # if not bool(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 to project_first

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

  the test is still green.

  if first_input:   vs return True
      return True   vs if first_input
  else:             vs else
      return False  vs False
  

• I remove True if and else False

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

  still green.

• I remove the other statements from project_first

  def project_first(first_input, second_input):
      return first_input
  

• I add a git commit message in the other 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 I get a notification?

  event	notification	event happened
  yes	yes	yes
  yes	no	yes (notification is broken)
  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 if the first input is True and the second input is True, to tests/test_binary.py

  first input	second input	return
  True	True	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 src/truth_table/__init__.py does not have anything named converse_implication in it.

---

GREEN: make it pass

---

I add a function definition for converse_implication to src/truth_table/__init__.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.

converse_implication(True , True ) -> True

---

REFACTOR: make it better

---

• I add an assertion for the second case, which is if the first input is True and the second input is False, to test_converse_implication in tests/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

  converse_implication(True , False) -> True
  converse_implication(True , True ) -> True
  

• time for the next case, which is if 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 src/truth_table/__init__.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

  converse_implication(False, True ) -> False
  converse_implication(True , False) -> True
  converse_implication(True , True ) -> True
  

• I add an assertion for the last case, which is if the first input is False and the second input is False, to test_converse_implication in tests/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 Python checks if first_input == False: when converse_implication is called

  • 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 False

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

  the test passes.

  converse_implication(False, False) -> True
  converse_implication(False, True ) -> False
  converse_implication(True , False) -> True
  converse_implication(True , True ) -> True
  

  Python checks if first_input == False: when converse_implication is called

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

    converse_implication(True , True ) -> True
    └── def converse_implication(first_input, second_input):
        ├── first_input  = True
        ├── second_input = True
        ├── if first_input == False:
        │       if second_input == True:
        │           return False
        └── return True
    

    converse_implication(True , False) -> True
    └── def converse_implication(first_input, second_input):
        ├── first_input  = True
        ├── second_input = False
        ├── if first_input == False:
        │       if second_input == True:
        │           return False
        └── return True
    

  • if first_input is equal to False, Python checks if second_input == True:

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

      converse_implication(False, False) -> True
      └── def converse_implication(first_input, second_input):
          ├── first_input  = False
          ├── second_input = False
          └── if first_input == False:
          ┌───┴── if second_input == True:
          │           return False
          └── return True
      

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

      converse_implication(False, True ) -> False
      └── def converse_implication(first_input, second_input):
          ├── first_input  = False
          ├── second_input = True
          └── if first_input == False:
              └── if second_input == True:
                  └── return False
              return True
      

  • it only checks the second input if the first input is True.

• 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 not bool(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 not bool(first_input) == True:
      if not bool(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 not bool(first_input) == True:
      # if not bool(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 not bool(something) == True is the same as if not bool(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 not bool(first_input) == True:
      # if not bool(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 not bool(first_input) == True:
      # if not bool(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 to converse_implication

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

  still green.

• I remove True if and else False

  def converse_implication(first_input, second_input):
      return (
          # True if
          first_input or not second_input
          # else False
      )
      # if first_input == 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  # logical_disjunction(True, False)
    True
    

  • 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   # logical_disjunction(True, 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  # logical_disjunction(False, 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  # logical_disjunction(False, True)
    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):
      return logical_disjunction(
          first_input,
          logical_negation(second_input)
      )
      return (
          # True if
          first_input or not second_input
          # else False
      )
  

  still green.

  converse_implication(False, False) -> True
  └── logical_disjunction(False, True ) -> True
  
  converse_implication(False, True ) -> False
  └── logical_disjunction(False, False) -> False
  
  converse_implication(True , False) -> True
  └── logical_disjunction(True , True ) -> True
  
  converse_implication(True , True ) -> True
  └── logical_disjunction(True , False) -> True
  

• I remove the commented lines from converse_implication

  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 the other 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 tests/test_binary.py and src/truth_table/__init__.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 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