Notebook 13 – Math 2121, Fall 2020

In this notebook we will explore how to draw complex numbers and then discuss a visual proof of the fundamental theorem of algebra.

The way we can visualize complex numbers is very similar to how we draw vectors in $R^{2}$ .

7.6 μs

xxxxxxxxxx
 
using Plots

14.2 s

xxxxxxxxxx
 
using PlutoUI

848 ms

xxxxxxxxxx
 
using LinearAlgebra

693 μs

In lecture, we defined the complex number $a + b i$ to be literally the $2 \times 2$ matrix

$[\begin{array}{rr} a & - b \\ b & a \end{array}] .$

A very useful way of visualizing the number $a + b i$ is by drawing the vector

$[\begin{matrix} a \\ b \end{matrix}] \in R^{2}$

which is the first column of the matrix above.

This first column determines the second column, so there is no loss of information.

11.2 μs

plot_vector (generic function with 2 methods)

58 μs

plot_sum (generic function with 2 methods)

77.8 μs

complex_product (generic function with 1 method)

39.3 μs

plot_multiple (generic function with 2 methods)

67 μs

We draw such vectors as arrows in the $x y$ -plane in the usual way.

7.3 μs

Int641

-2

xxxxxxxxxx
 
u = [-2;2]

8.6 μs

This represents the complex number $u$ = -2 + 2i.

8.3 ms

Int641

xxxxxxxxxx
 
v = [4; 2]

3.6 μs

This represents the complex number $v$ = 4 + 2i.

11.6 μs

The sum of these complex numbers is $u + v$ = 2 + 4i.

In terms of arrows, the sum $u + v$ corresponds to translating the start of $v$ to the end of $u$ and the following the origin to the endpoint of the translated copy of $v$ .

27.3 μs

6.1 s

There is also a simple of way of visualizing the product of two complex numbers.

The length or norm of $z = a + b i$ is $| z | = \sqrt{a^{2} + b^{2}}$ .

This is also how we define the length of the vector $[\begin{array}{r} a \\ b \end{array}]$ .

The angle of the vector $[\begin{array}{r} a \\ b \end{array}]$ is the angle that the vector makes with the positive $x$ -axis.

The angle of $z = a + b i$ is defined to be the angle of $[\begin{array}{r} a \\ b \end{array}]$

The complex number $z$ is uniquely determined by its length and angle:

If these are $r$ and $θ$ , respectively, then $z = r \cos θ + i r \sin θ$ .

Here is a method to compute the angle of $z$ :

14.6 μs

angle (generic function with 1 method)

xxxxxxxxxx
 
function angle(z)
    # returns angle between 0.0 and 2 * pi
    
    u1, u2 = z[1], z[2]
    
    if u1 == 0
        return u2 > 0 ? pi/2 : 3 * pi/2
    end
    
    if u2 == 0
        return u1 > 0 ? 0 : pi
    end
​
    a = atan(abs(u2) / abs(u1))
    
    if u1 > 0 && u2 > 0
        return a
    elseif u1 > 0 && u1 > 0
        return 2 * pi - a
    elseif u1 < 0 && u2 > 0
        return pi - a
    else
        return pi + a
    end
end

43.5 μs

Here is how to interpret the product of two complex numbers $y$ and $z$ in terms of arrows:

The vector in $R^{2}$ representing $y z$ is the vector whose angle is the sum of the angles of $y$ and $z$ , and whose length is the product of the lengths of $y$ and $z$ .

6.9 μs

Recall that u = -2 + 2i and v = 4 + 2i.

11.3 μs

2.82843

2.35619

xxxxxxxxxx
 
norm(u), angle(u)

103 ms

4.47214

0.463648

xxxxxxxxxx
 
norm(v), angle(v)

7.5 μs

Int641

-12

xxxxxxxxxx
 
uv = complex_product(u, v)

12.5 ms

2×2 Array{Float64,2}:
 12.6491  2.81984
 12.6491  2.81984

xxxxxxxxxx
 
[norm(uv) angle(uv); norm(u) * norm(v) angle(u) + angle(v)]

27.8 μs

197 ms

Some more examples of products of complex numbers:

8.1 μs

1×2 Array{Float64,2}:
 1.414  1.414

86.3 ms

1×2 Array{Float64,2}:
 -0.3535  0.3535

xxxxxxxxxx
 
z = [-0.707 0.707] / 2

53.1 ms

These vectors represent y = 1.414 + 1.414i and z = -0.3535 + 0.3535i

3.3 ms

These numbers have length $2$ and $1 / 2$ , so the length of their product is $1$ .

The angle of $y$ is $π / 4$ and the angle of $z$ is $3 π / 4$ , so the angle of $y z$ is $π / 4 + 3 π / 4 = π$ radians.

30.3 μs

1.9997

0.499924

0.999698

0.999698

xxxxxxxxxx
 
norm(y), norm(z), norm(y) * norm(z), norm(complex_product(y, z))

159 ms

0.785398

2.35619

3.14159

π

xxxxxxxxxx
 
angle(y), angle(z), angle(y) + angle(z), angle(complex_product(y, z))

21.5 ms

331 ms

2.7 ms

Multiplying by $i$ corresponds to rotating by $π / 2$ radians.

49.8 μs

12 ms

These pictures give us some visual intution about adding, multiplying, and taking powers $z \mapsto z^{n}$ of complex numbers. The last operation corresponds to multiplying the angle of the arrow representing $z$ by $n$ and exponentiating the length.

Using these abilities together lets us imagine the output of a polynomial function

$f (x) = z_{0} + z_{1} x + z_{2} x^{2} + \dots + z_{n} x^{n}$

where $x$ is a variable and $z_{0}, z_{1}, \dots, z_{n} \in C$ .

We can encode such a function in Julia as a $2 \times (n + 1)$ real matrix, whose columns record the coefficients $z_{0}, z_{1}, \dots, z_{n}$ . Here are some methods to create polynomials encoded like this:

12.6 μs

random_real_polynomial (generic function with 1 method)

xxxxxxxxxx
 
function random_real_polynomial(degree)
    return rand(-10:10, 1, degree + 1)
end

24.7 μs

random_complex_polynomial (generic function with 1 method)

xxxxxxxxxx
 
function random_complex_polynomial(degree)
    return rand(-10:10, 2, degree + 1)
end

25.8 μs

monomial (generic function with 1 method)

xxxxxxxxxx
 
function monomial(degree)
    ans = zeros(1, degree + 1)
    ans[1, end] = 1
    return ans
end

23.4 μs

Here is a very simple method to print a 2-row matrix as a polynomial in the usual way.

6.2 μs

print_polynomial (generic function with 1 method)

48.9 μs

1×6 Array{Int64,2}:
 6  -2  -8  4  6  -9

xxxxxxxxxx
 
f = random_real_polynomial(5)

19.4 ms

(6) + (-2) * x + (-8) * x^2 + (4) * x^3 + (6) * x^4 + (-9) * x^5

xxxxxxxxxx
 
Text(print_polynomial(f))

40.8 ms

2×5 Array{Int64,2}:
 -5  -3  10    0  -2
 -7   0  -4  -10   1

xxxxxxxxxx
 
g = random_complex_polynomial(4)

4.9 ms

(-5 + -7i) + (-3 + 0i) * x + (10 + -4i) * x^2 + (0 + -10i) * x^3 + (-2 + 1i) * x^4

xxxxxxxxxx
 
Text(print_polynomial(g))

28.4 μs

1×8 Array{Float64,2}:
 0.0  0.0  0.0  0.0  0.0  0.0  0.0  1.0

xxxxxxxxxx
 
h = monomial(7)

12 ms

(1.0) * x^7

xxxxxxxxxx
 
Text(print_polynomial(h))

37.9 ms

The following method evaluates our polynomial $f$ at a complex number $z = a + b i$ , assuming that $f$ is inputted as a 1- or 2-row array and $z$ is inputted as the 2-row vector $[\begin{matrix} a \\ b \end{matrix}]$ .

6.8 μs

evaluate_polynomial (generic function with 1 method)

xxxxxxxxxx
 
function evaluate_polynomial(f, z)
    ans = zeros(2, 2)
    
    # convert z back to 2-by-2 matrix
    z = [z[1] -z[2]; z[2] z[1]]
    
    m, n = size(f)
    degree = n - 1
​
    for i=0:degree
        a = f[1, i + 1]
        b = m == 1 ? 0 : f[2, i + 1]
        
        # convert coefficient of f back to 2-by-2 matrix
        coefficient = [a -b; b a]
        
        # multiply together and add
        ans += coefficient * z^i
    end
    
    # return just first columne of 2-by-2 matrix
    return ans[:, 1]
end

50.2 μs

1Float641

-3.0

0.0

-3

xxxxxxxxxx
 
# evaluates f(x) at x = 1 = 1 + 0i
evaluate_polynomial(f, [1, 0]), sum(f) 

939 ms

1Float641

20.0

-15.0

2Int641

-15

xxxxxxxxxx
 
# evalutes f(x) at x = i = 0 + i
evaluate_polynomial(f, [0, 1]), [f[1] - f[3] + f[5], f[2] - f[4] + f[6]]

3.1 ms

To visualize a set of complex numbers $z = a + b i$ , we just draw the endpoints of the vectors $[\begin{matrix} a \\ b \end{matrix}]$ .

Below is a picture of the set ${z \in C : | z | = 2}$ , which forms a circle:

7.3 μs

circle_path (generic function with 2 methods)

xxxxxxxxxx
 
function circle_path(r, N=1000)
    path = zeros(2, N)
    for n = 0:N - 1
        path[1, n + 1] = r * cos(2 * pi / N * n)
        path[2, n + 1] = r * sin(2 * pi / N * n)
    end
    return path
end

48.1 μs

plot_path (generic function with 2 methods)

xxxxxxxxxx
 
function plot_path(path, title="")
    plot(path[1,:], path[2,:], aspect_ratio=:equal, title=title, legend=false)
    scatter!([0], [0])
end

34.6 μs

479 ms

Below are the analogous pictures ${f (z) : | z | = 2}$ , ${g (z) : | z | = 2}$ , and ${h (z) : | z | = 2}$ .

9.3 μs

compute_path (generic function with 1 method)

xxxxxxxxxx
 
function compute_path(f, domain)
    # evaluates polynomial f at all columns in domain
    
    _, N = size(domain)
    path = zeros(2, N)
    for n = 1:N
        path[:, n] = evaluate_polynomial(f, domain[:, n])
    end
    return path
end

36.4 μs

1.5 s

2.8 ms

124 ms

The picture of ${h (z) : | z | = 2}$ is also a circle, but of radius 128.

This makes sense because $h (x) = x^{n}$ for $n$ = 7.

(Can you explain this using our visual interpretation of complex multiplication?)

4.7 ms

Fundamental theorem of algebra

The fundamental theorem of algebra result says that if $n > 0$ then any polynomial

$p (x) = z_{0} + z_{1} x + z_{2} x^{2} + \dots + z_{n} x^{n}$

with $z_{n} \neq 0$ can be factored as

$p (x) = z_{n} (x - α_{1}) (x - α_{2}) \dots (x - α_{n})$

for some complex numbers $α_{1}, α_{2}, \dots, α_{n} \in C$ which do not need to be distinct.

We can sketch a visual proof of this fact, extending the discussion above.

17.8 μs

Enter cell code...xxxxxxxxxx
 
​

411 ns

Some preliminaries:

Fact. If $p (0) = 0$ then $p (x) = x q (x)$ for some polynomial $q (x)$ .

Proof: This is obvious since $p (0) = z_{0}$ .

Fact. If $p (α) = 0$ then $p (x) = (x - α) q (x)$ for some polynomial $q (x)$ .

Proof: If $p (α) = 0$ then the polynomial $f (x) = p (x + α)$ has $f (0) = 0$ , so $f (x) = x g (x)$ .

But then $p (x) = f (x - α) = (x - α) q (x)$ for the polynomial $q (x) = g (x - α)$ .

Conclusion. To prove the fundamental theorem of algebra, it suffices to show that if $n > 0$ then

$p (α) = 0$

for some complex number $α \in C$ .

A proof of this last property is what we will outline below.

19 μs

Enter cell code...xxxxxxxxxx
 
​

621 ns

Our proof involves the notion of the winding number of a curve in $R^{2}$ .

Consider a circle ${z \in R^{2} : | z | = r}$ . We order the points on this circle to start at the unique point the positive $x$ -axis and travel counterclockwise.

Passing the points on the circle in order as inputs to $p (x)$ traces a curve in $R^{2}$ . The winding number of this curve is the number of times the curves goes completely around the origin counter clockwise.

10.9 μs

winding_number (generic function with 1 method)

xxxxxxxxxx
 
function winding_number(p, r)
    # computes winding number of curve tracing { p(z) : |z| = r }
    
    # here is the simple idea to compute this: 
    #
    # * take two successive points z_0, z_1 on the circle
    # * compute the small change in angles between these points
    # * add up these angle changes over the whole circle, then divide by 2 pi
    #
    # "adding" in this context is secretly some kind of integration
    
    domain = circle_path(r)
    path = compute_path(p, domain)
    
    _, N = size(path)
    ans = zeros(1, N)
    for i=1:N - 1
        z_0 = path[:, i]
        z_1 = path[:, i + 1]
        
        angle_0 = angle(z_0)
        angle_1 = angle(z_1)
        
        dtheta = angle_1 - angle_0
        
        # we have to adjust dtheta in the case when our angle function returns
        # something close to 0 for z_0 and close to 2 pi for z_1 (or vice versa)
        if dtheta > pi
            dtheta -= 2 * pi
        elseif dtheta < -pi
            dtheta += 2 * pi
        end
        
        ans[i + 1] = ans[i] + dtheta / 2 / pi
    end
    return ans
end

49.4 μs

plot_winding (generic function with 1 method)

xxxxxxxxxx
 
function plot_winding(f, r)
    deg = size(f)[2] - 1
    domain = circle_path(r)
    path = compute_path(f, domain)
    winding = winding_number(f, r)
    p1 = plot_path(domain, "{ z: |z| = $(r) }")
    p2 = plot_path(path, "{ p(z): |z| = $(r) }")
    p3 = plot(transpose(winding), legend=false, ylimit=(-1, deg + 1), title="winding")
    plot(p1, p2, p3, layout=(1,3))
end

45 μs

For example, $p (x) = - 1 + x + x^{2}$ has winding number 1 for $r = 1$ :

10.9 μs

572 ms

However, for $r = 2$ the polynomial $p (x) = - 1 + x + x^{2}$ has winding number $2$ :

9.3 μs

5.7 ms

Whereas for $r = 0.5$ the same polynomial has winding number $0$ :

7.8 μs

xxxxxxxxxx
 
plot_winding([-1 1 1; 0 0 0], 0.5)

89.5 ms

Keys facts:

If $p (0) \neq 0$ and $r$ is very small, the winding number will be zero.
If $p (x) = x^{n}$ then the winding number will always be $n$ , for any $r$ .
If $p (x)$ has degree $n$ and $r$ is very large, then $p (x)$ has the same winding number as $x^{n}$ .

7.8 μs

2×8 Array{Int64,2}:
 -9  -1  -1   10  -5  7  -3  -5
 -9  -9   9  -10   8  0  -5  -8

xxxxxxxxxx
 
p =  random_complex_polynomial(7)

6.6 μs

"(-9 + -9i) + (-1 + -9i) * x + (-1 + 9i) * x^2 + (10 + -10i) * x^3 + (-5 + 8i) * x^4 + (7 + 0i) * x^5 + (-3 + -5i) * x^6 + (-5 + -8i) * x^7"

xxxxxxxxxx
 
print_polynomial(p)

16.8 μs

parameter =

116 ms

1.87265

32.2 μs

winding

9.9 ms

xxxxxxxxxx
 
plot_winding(p, r)

10.6 ms

Why does this prove the fundamental theorem of algebra?

Winding number can only change as we vary $r$ if ${p (z) : | z | = r}$ passes through the origin.
This must happen if $p (x)$ has degree $n > 0$ and $p (0) \neq 0$ .
(Since the winding number is zero if $r$ is small and the winding number is $n$ if $r$ is large.)
But this means for some real $r > 0$ there is an $α \in C$ with $| α | = r$ and $p (α) = 0$ .

9 μs