Logic

Boolean Values

The boolean type has only two values: True and False. Let's assign a boolean value to a variable and verify the type using the built-in function type():

python_is_fun = True
print(python_is_fun)
True
type(python_is_fun)
bool

Let's assign the value False to a variable and again verify the type:

math_is_scary = False
print(math_is_scary)
False
type(math_is_scary)
bool

Comparison Operators

Comparison operators produce Boolean values as output. For example, if we have variables x and y with numeric values, we can evaluate the expression x < y and the result is a boolean value either True or False.

Comparison Operator Description
< strictly less than
<= less than or equal
> strictly greater than
>= greater than or equal
== equal
!= not equal

For example:

1 == 2
False
1 < 2
True
2 == 2
True
3 != 3.14159
True
20.00000001 >= 20
True

Boolean Operators

We combine logical expressions using boolean operators and, or and not.

Boolean Operator Description
A and B returns True if both A and B are True
A or B returns True if either A or B is True
not A returns True if A is False

For example:

(1 < 2) and (3 != 5)
True
(1 < 2) and (3 < 1)
False
(1 < 2) or (3 < 1)
True
not (1000 <= 999)
True

if statements

An if statement consists of one or more blocks of code such that only one block is executed depending on logical expressions. Let's do an example:

# Determine if roots of polynomial ax^2 + bx + c = 0
# are real, repeated or complex using the
# quadratic formula x = (-b \pm \sqrt{b^2 - 4ac})/2a
a = 10
b = -234
c = 1984
discriminant = b**2 - 4*a*c
if discriminant > 0:
    print("Discriminant =", discriminant)
    print("Roots are real and distinct.")
elif discriminant < 0:
    print("Discriminant =", discriminant)
    print("Roots are complex.")
else:
    print("Discriminant =", discriminant)
    print("Roots are real and repeated.")
Discriminant = -24604
Roots are complex.

The main points to observe:

  1. Start with the if keyword.
  2. Write a logical expression (returning True or False).
  3. End line with a colon :.
  4. Indent block 4 spaces after if statement.
  5. Include elif and else statements if needed.
  6. Only one of the blocks if, elif and else is executed.
  7. The block following an else statement will execute only if all other logical expressions before it are False.

Examples

Invertible Matrix

Represent a 2 by 2 square matrix as a list of lists. For example, represent the matrix

$$ \begin{bmatrix} 2 & -1 \\ 5 & 7 \end{bmatrix} $$

as the list of lists [[2,-1],[5,7]].

Write a function called invertible which takes an input parameter M, a list of lists representing a 2 by 2 matrix, and returns True if the matrix M is invertible and False if not.

def invertible(M):
    '''Determine if M is invertible.

    Parameters
    ----------
    M : list of lists
        Representation of a 2 by 2 matrix M = [[a,b],[c,d]].

    Returns
    -------
    bool
        True if M is invertible and False if not.

    Examples
    --------
    >>> invertible([[1,2],[3,4]])
    True
    '''
    # A matrix M is invertible if and only if
    # the determinant is not zero where
    # det(M) = ad - bc for M = [[a,b],[c,d]]
    determinant = M[0][0] * M[1][1] - M[0][1] * M[1][0]
    if determinant != 0:
        return True
    else:
        return False

Let's test our function:

invertible([[1,2],[3,4]])
True
invertible([[1,1],[3,3]])
False

Concavity of a Polynomial

Write a function called concave_up which takes input parameters p and a where p is a list representing a polynomial $p(x)$ and a is a number, and returns True if the function $p(x)$ is concave up at $x=a$ (ie. its second derivative is positive at $x=a$, $p''(a) > 0$).

We'll use the second derivative test for polynomials. In particular, if we have a polynomial of degree $n$

$$ p(x) = c_0 + c_1 x + c_2 x^2 + \cdots + c_n x^n $$

then the second derivative of $p(x)$ at $x=a$ is the sum

$$ p''(a) = 2(1) c_2 + 3(2)c_3 a + 4(3)c_4 a^2 + \cdots + n(n-1)c_n a^{n-2} $$

def concave_up(p,a):
    '''Determine if the polynomial p(x) is concave up at x=a.

    Parameters
    ----------
    p : list of numbers
        List [a_0,a_1,a_2,...,a_n] represents the polynomial
        p(x) = a_0 + a_1*x + a_2*x**2 + ... + a_n*x**n

    Returns
    -------
    bool
        True if p(x) is concave up at x=a (ie. p''(a) > 0) and False otherwise.

    Examples
    --------
    >>> concave_up([1,0,-2],0)
    False
    >>> concave_up([1,0,2],0)
    True
    '''
    # Degree of the polynomial p(x)
    degree = len(p) - 1

    # p''(a) == 0 if degree of p(x) is less than 2
    if degree < 2:
        return False
    else:
        # Compute the second derivative p''(a)
        DDp_a = sum([k*(k-1)*p[k]*a**(k-2) for k in range(2,degree + 1)])
        if DDp_a > 0:
            return True
        else:
            return False

Let's test our function on $p(x) = 1 + x - x^3$ at $x=2$. Since $p''(x) = -6x$ and $p''(2) = -12 < 0$, the polynomial is concave down at $x=2$.

p = [1,1,0,-1]
a = 2
concavity = concave_up(p,a)
print(concavity)
False

Exercises

  1. The discriminant of a cubic polynomial $p(x) = ax^3 + bx^2 + cx + d$ is

    $$ \Delta = b^2c^2 - 4ac^3 - 4b^3d - 27a^2d^2 + 18abcd $$

    The discriminant gives us information about the roots of the polynomial $p(x)$:

    • if $\Delta > 0$, then $p(x)$ has 3 distinct real roots
    • if $\Delta < 0$, then $p(x)$ has 2 distinct complex roots and 1 real root
    • if $\Delta = 0$, then $p(x)$ has at least 2 (real or complex) roots which are the same

    Represent a cubic polynomial $p(x) = ax^3 + bx^2 + cx + d$ as a list [d,c,b,a] of numbers. (Note the order of the coefficients is increasing degree.) For example, the polynomial $p(x) = x^3 - x + 1$ is [1,-1,0,1].

    Write a function called cubic_roots which takes an input parameter p, a list of length 4 representing a cubic polynomial, and returns True if $p(x)$ has 3 real distinct roots and False otherwise.

  2. Represent a 2 by 2 square matrix as a list of lists. For example, represent the matrix

    $$ \begin{bmatrix} 2 & -1 \\ 5 & 7 \end{bmatrix} $$

    as the list of lists [[2,-1],[5,7]]. Write a function called inverse_a which takes an input parameter a and returns a list of lists representing the inverse of the matrix

    $$ \begin{bmatrix} 1 & a \\ a & -1 \end{bmatrix} $$

  3. Write a function called real_eigenvalues which takes an input parameter M, a list of lists representing a 2 by 2 matrix (as in the previous exercise), and returns True if the eigenvalues of the matrix M are real numebrs and False if not.