******************* Propositional Logic ******************* * Sometimes things are ``True`` or ``False`` * This course focuses on introductory computer science --- ``True`` * This topic is titled "Not Logic" --- ``False`` * This is rather intuitive since you use this type of simple logic in every day life to make decisions * Additionally, you are already familiar with some *operators* we can use on these ``True``/``False`` statements * ``and`` * ``or`` * ``not`` Truth Table =========== .. list-table:: Truth Table :widths: 50 50 50 50 50 :header-rows: 1 * - A - B - A ``and`` B - A ``or`` B - ``not`` A * - ``True`` - ``True`` - ``True`` - ``True`` - ``False`` * - ``True`` - ``False`` - ``False`` - ``True`` - ``False`` * - ``False`` - ``True`` - ``False`` - ``True`` - ``True`` * - ``False`` - ``False`` - ``False`` - ``False`` - ``True`` * The above *truth table* is a rather formal representation of some everyday ideas * To put it slightly different * Is *the sky blue* ``and`` is *water wet*? --- ``True`` * Is *the sky blue* ``and`` is it *over 100 degrees Celsius outside*? --- ``False`` * Is *the sky blue* ``or`` is it *over 100 degrees Celsius outside*? --- ``True`` * Is it ``not`` *over 100 degrees Celsius outside*? --- ``True`` * Is *the sky blue* ``and`` is it ``not`` *over 100 degrees Celsius outside*? --- ``True`` * You may have observed that * For ``and``, both statements must be ``True`` to produce ``True``, otherwise it is ``False`` * For ``or``, only one statement must be ``True`` to produce ``True``, otherwise it is ``False`` * ``not`` changes ``True`` -> ``False`` and ``False`` -> ``True`` .. note:: For ``or``, both statements being ``True`` produces ``True``. There is another operator called *exclusive or* that is ``True`` only when one of the statements is ``True``. Exclusive or is not going to come up in this course and it is only noted here since some people find ``or`` ambiguous at first. .. raw:: html Boolean Type ============ * `Booleans `_ are a type in Python, like integers, strings, and floats * ``type(True)`` gives us ``bool`` * Unlike integers, strings, and floats which can take on many different values, booleans can only be one of two values * ``True`` * ``False`` Boolean Operators ----------------- * Just like the arithmatic operators we use on integers and floats, Booleans have operators too * The ones we just used * ``and`` * ``or`` * ``not`` * Consider the arithmatic operator ``+`` * It takes two number *operands* * It produces a new number as a result * e.g., ``1 + 2`` is ``3`` * For Booleans, consider ``and`` * It takes two *Boolean* operands * It produces a new Boolean as a result * e.g., ``True and False`` is ``False`` Comparison Operators -------------------- * As you have probably noticed, asking ``True and False`` is not overly helpful as it is * Based how we use this logic in real life, we need a way to evaluate statements into their Boolean values * For example, is it ``not`` *over 100 degrees Celsius outside*? * We need a way to check if the given temperature is greater than 100 degrees Celsius * For these situations, we make use of comparison operators you already use in your everyday life * Is five greater than three? * ``5 > 3`` is ``True`` * More generally, these comparison operators take values to be compared * Consider the greater than (``>``) comparison operator * It two values as operands * It produces a Boolean as a result * e.g., ``1 > 7`` is ``False`` * The comparison operators we make use of are * Equal ``==`` * Not equal ``!=`` * Greater than ``>`` * Greater than or equal ``>=`` * Less than ``<`` * Less than or equal ``<=`` .. admonition:: Activity :class: activity Play around with the above operators on different integers and see if you can find operands that produce ``True``/``False`` for each. Play around with the operators on different types. For example, what happens when you compare Booleans, floats, and strings? .. warning:: Mind the use of two equal signs (``==``) for checking equality. Remember, a single equals sign (``=``) is the assignment operator. * ``some_variable = 5`` assigns the value ``5`` to the variable ``some_variable`` * ``some_variable == 5`` checks if the value stored in ``some_variable`` is equal to the value ``5`` Composing Operators and Values ============================== * We have seen different operators that work on different types * As long as the types check out and we follow the `order of operations `_, we can compose rather complex expressions * Don't worry about memorizing the order of operations * They follow what you are used to for the most part * When in doubt, make use of parentheses Evaluating Example Expressions ------------------------------ ``((17 + 2) < 18) or (17 != 18)`` ``(19 < 18) or (17 != 18)`` ``False or (17 != 18)`` ``False or True`` ``True`` ``(101 == 100) and ((66 - 17) < 54))`` ``False and ((66 - 17) < 54)`` ``False and (49 < 54)`` ``False and True`` ``False`` * Once we evaluated ``(101 == 100)`` as ``False``, we didn't need to evaluate the remainder of the expression * With ``and``, if one of the operands are ``False``, the whole expression evaluated to ``False`` ``(14 > 0) or ((6 != 7) and ((4 + 17) < 20))`` ``True or ((6 != 7) and ((4 + 17) < 20))`` ``True or (True and ((4 + 17) < 20))`` ``True or (True and (21 < 20))`` ``True or (True and False)`` ``True or False`` ``True`` * Notice that once we evaluated ``(14 > 0)`` as ``True``, we really didn't need to finish evaluating the remainder of the expression * This is because, as long as one of the operands for an ``or`` is ``True``, we know the whole expression is ``True`` .. warning:: If you find yourself writing long and complex boolean expressions, chances are you are doing something wrong. Even if we have a long list of conditions you need to check in your program, there are ways to make them more manageable and easier to follow. For Next Class ============== * If you have not yet, read `Chapter 5 of the text `_