Unforgivable Math Pun Alert: Getting Triggy With It

Had fun at a local library looking through the book Trigonometric Delights by Eli Maor, the author of one of my favorite math-geek books, e: The Story of a Number. Maor often approaches math problems from an unexpected angle and in Chapter 7 he tackles the equations behind the artsy toy from the '70s, the Spirograph.

For those familiar with polar equations, it's easy to figure out the coordinates of point C in the figure (the center of the small circle) with respect to O, the origin. But it's more difficult to find out the coordinates of point P with respect to O. This alone would make a great trig exploration for somebody's precalculus class. But Maor points out that the angles of rotation, theta and phi, are not independent; the arc lengths on the two circles must be equal (because their circumferences are connected by the gears). He substitutes phi = [(R - r)/r]*theta to get everything in terms of theta:

Now that's a couple of parametric equations that were made for a computer! Let's get a turtle to play Spirograph.

Since Python makes a distinction between uppercase R and lowercase r, I could put those equations in almost verbatim. But there's no symbol for theta, so I created a variable "theta."

The rest of the Python code (available here) is just a loop so the turtle goes to that x,y coordinate, then increase theta a little, recalculate x and y and go to that coordinate, over and over and over. But what I got out wasn't what I expected.

None of the output had curved loops, but pointed ends instead. Then I realized that Maor's equations assumed the "pen" was right on the edge of the smaller circle, not somewhere in the middle. I added a variable p for "proportion" to the second term of the formulas:

That got me a much more realistic Spirograph:

Later in the chapter Maor deals with cases of different ratios of R/r, such as 2, when you simply get a horizontal line. "Even more interesting is the case R/r = 4," when you get a four-pronged thingy:

"Interesting"? I don't know, but if you change the proportion variable, you get a slightly different thingy. 

Keep going with this Maor says you get an "Astroid," which looks like this:

So I modified my code to draw a thingy (theta goes from 0 to 2*pi), then lower the proportion variable and draw another one and so on. I didn't get an astroid but something wholly unexpected:

This is something that can't be made with the physical Spirograph, but using computers and extending patterns, a lot of interesting things suddenly become possible!

Even changing the proportion so it goes up rather than down didn't get me the textbook astroid:

I'm trying to decide which one to call "The Farrell Hypercycloid."

A Recipe for Transformation

I first learned about matrices in a Business Math course in college and we painstakingly manipulated them by hand. It was not love at first sight.

But now it's 2014 and students are still multiplying matrices by hand and are never getting to see their transformational power. I say that literally because matrices are used to transform (rotate, reflect, translate) points in a 2 or 3-D plane. What would video games be without rotation matrices? That's right: Pong.

Unfortunately many textbooks neglect this graphical application which could be used to grab students' attention. Good for us Don "The Mathman" Cohen didn't neglect it. On the contrary, he and his very young students graphed a simple "dog" and multiplied its points one by one and graphed the result. Their work can be found in Cohen's characteristically clear, engaging and thought-provoking book "Changing Shapes with Matrices."

When I was working with a homeschooled Algebra 2 student on matrices, we used Python and its professional-strength numerical package Numpy to multiply and transform our matrices.

But if you're just using a 2x2 transformation matrix, it's not hard to write your own functions in Python to draw and multiply matrices. Since I don't have to do the multiplying by hand, I can use more points than Cohen did. I chose to transform a big F since it has no rotational or reflective symmetry and my last name starts with F. First draw it on graph paper (or Geogebra) to get the points:

Now type the points into an n x 2 matrix:

Ok, it's just a list. But we're using our imagination here. Now enter your favorite transformation matrix:

I wrote a function to connect the points in a matrix using the create_line function in Tkinter. But the important function (and one I think math teachers could benefit from assigning their students) is the one that multiplies two matrices together. a is the n x 2 matrix (it can have any number of rows) and b is the 2x2 transformation matrix:

The above code isn't obvious. i needs to go up by 2 in order to skip from point to point, and j only has 2 values. But the a[i]*b[j] line is especially guaranteed to challenge math students! It'll make them think about how you multiply matrices, that's for sure:

Now just have the program multiply the F-matrix by the transformation matrix and graph the result:

This transformation matrix reflects every point across the line y = -x. Or is it a rotation, then a reflection? Change one number in your transformation matrix and you'll get a shear in the vertical direction:

Notice the new x-value is the old y-value and the new y-value is the negative of the sum of the old x- and y-values. I think this is exactly the kind of exploration math students should be getting so they can experience transformations and matrices first hand. I suspect this can all be done with a couple of keystrokes in IPython but doing some real programming to multiply matrices and graph the result is a great exercise!

Making the Mandelbrot

I've taught students to draw fractals like the Koch Snowflake in Logo and Python. The Sierpinski triangle and the Dragon Curve aren't hard to figure out, either. But the Mandelbrot Set always seemed like a different animal altogether. Sure, every math textbook has pictures of the famous pear-shaped fractal, but none teach you how to create it. Students and teachers get the feeling it must be something unapproachable, requiring years of training, but, predictably enough, a computer makes it easy.

It boils down to taking a point in the complex plane and iterating it using the formula:

c is a complex number of the form a + bi, where i is the square root of -1. Z is set to 0 initially, then you square it and add c. The result becomes the new Z. Square it and add c. Repeat a bunch of times. I think it's a great exercise for Precalculus students to write a program to do this.

As Paul Lutus explained visually, most points will get really large, and fly off out of the "control radius":

the ones that stay within the control radius are in the Mandelbrot Set.

So at first the set of points that don't fly off is big:

But iteration by iteration more and more points fly off ("diverge") and the blob starts to take the shape we know and love:

The challenge is how to take points (especially ones with a real part and an imaginary part) and put the coordinates into a function over and over. Many online examples require the use of numpy and other (very useful) Python add-ons, but I wanted to do it with only "stock" Python tools.

First I had to define a function to square the complex number a bunch of times. Every programming language has a way to handle lists, and Python's way is pretty easy. I made a 2-item list of numbers: the first item is the real part of the complex number and the second item is the imaginary part. Here's how to represent the complex number 2 + 3i:

Anybody familiar with multiplying polynomials can get their noggin around this:

The only thing separating this Precalculus exercise from an Algebra one is imaginary numbers, which I've mentioned before. When the imaginary part is squared it becomes real but negative. Now squaring complex numbers is easy:

This means the square of 2 + 3i is -5 + 12i and the square of 1 - i is -2i (the real part of the last list is zero).

Now it's just a matter of calling the squareZ function then adding c back in. This next function just tells you whether the squaring-adding is making the numbers get really big. If so, the original c is not in the Mandelbrot set.

If after all your iterating the point hasn't gotten more than 2 units away from the origin it's in the Mandelbrot set. So in the above blobs that point would be colored black. That was the tricky part. What's the best way to display the results? Will the easiest way look the best?

The original output in 1978 was text, and Paul Lutas' page contains the code needed to generate it. Here's my version, which didn't all fit on the screen at once:

It's exciting just to get that far! But I knew my students would probably want something more professional looking.

In his excellent book Python for Kids, Jason Briggs showed how to use Tkinter, the default graphics module in Python, to draw shapes and create a video game. So in my program the loops go through the rows and columns of the screen, iterating each point and coloring those in the Mandelbrot Set black. In an 800 x 800 screen that means it has 640,000 points to iterate!

To set up the screen, you have to import tkinter and put this code at the top of the program:

Finally, the main loop of the program looks like this:

The program starts at (xlow, ylow) and checks the point. If it stays within the control radius after 20 iterations it creates a one-pixel black square, otherwise it doesn't do anything and moves on to the next point. Here's how it looks:

The color pictures you see online are made by coloring the points that diverge every step. This requires some changes to the code (which I'll spare you) but it makes it look pretty. You'll recognize the colored shapes as the black blobs from above:

Python is a (relatively) easy way to explore ideas like iteration that would otherwise be impossible with just pencil and paper. Try it!

Hacking Math Class with Python

I posted my Elliptical Orbits video to a math teachers' Google group and it got around to somebody in the Bay Area Python Interest Group. They invited me to LinkedIn headquarters in Mountain View, CA to talk about using technology and Python programming to help teach and learn difficult concepts in math and science.



I definitely wasn't there to teach anybody anything, but just to share my experiences combining math and computers. As you can see in the video, people were making great suggestions, so I learned a lot, too!

Let it Snow (flake)

If you're interested at all in learning or teaching math, you either have already read or you should probably read Don Cohen's mind-blowing Calculus By and For Young People, a tiny book that packs a huge wallop. In it, "The Mathman" busts the myth that you need 11 years of school math to even approach the ideas in Calculus by showing the work his students (children as young as 7) have done on infinite series, fractals, derivatives and integrals, pi, e and of course the Fibonacci Numbers. And continued fractions. And nested square roots.

Recently Don sent me some work a student did on converting repeating decimals to fractions. It reminded me of how long I studied Chapter 1 of his book a decade ago. Every math student I taught after that got to play around with infinite series until they discovered the deceptively simple formula Cohen reveals on page 9.

The book bounces around playfully until returning to the topic with Chapter 4: The Snowflake Curve, the greatest eight pages of any math book ever written. The aforementioned formula is used to calculate the area inside the Koch Snowflake fractal. The power and simplicity of the ideas in this tiny book still make me shake my head in disbelief. Buy it and do the math.

Drawing the Koch Snowflake was one of the programming projects I did recently with the students I teach at the Summit Charter schools in the SF Bay Area.

The challenge is to start with a triangle (level 0) and add little angles to the middle of every segment. Repeat for higher levels. 

The graphics above were made using the NetLogo application of the Logo programming language. But how do you get a turtle to stop in the middle of a segment? The answer is recursion. 

All the code necessary was found in Turtle Geometry by Ableson and diSessa, another brilliant book, which I found at a not-nearby library and bought shortly thereafter. I only had to modify the code a little to work in NetLogo, and surprisingly, the program is short and simple:

The "snowflake" procedure simply draws a triangle with three sides. It's the "side" procedure where the magic happens. I had to tell the turtle how to make the little bend in the side. But notice that the "side" procedure contains the command "side"! It's like a recipe for baking a loaf of bread including the step "bake a loaf of bread." That's recursion. We humans would stop in our tracks at such a command but I guess computers have no problem with it. Anyway, you can have fun making a computer draw a curve with an infinite perimeter and a finite area or you can sharpen your pencil and prove it yourself!

3D Harmonographs

Success! I looked through this guy's site and found the equations for the x-y motion of the "pen" drawing a harmonograph. He shows a Mathematica program that uses sliders to dynamically change the frequencies, phase shifts and decay constants and immediately see the finished harmonograph.

When I wrote those equations in a Python program it came out perfect. It takes my program a while to draw the image, but then so do real harmonographs.

I had other ideas, though: moving the sliders, I couldn't help but feel like the images were a 3D object being rotated. Then it hit me: I could draw harmonographs using a Visual Python program where one sphere (the "pen") goes back and forth in all 3 planes! I think it worked pretty well. Check it out:

Harmonographs

For years I've been fascinated with harmonographs, even before seeing one at the SF Exploratorium. Of course it made me want to create a virtual one on the computer, but the equations modeling the movement of the x- and y-coordinates of the drawing point were kind of confusing.

Visual Python makes it easy to draw in 3-D, but for some reason the paths, even once drawn, start to glitch.

This guy did a great harmonograph in Javascript. Maybe it's time to break out some more JS on Glowscript.org.

I'll keep you posted.