I’m teaching Multivariable Calculus this semester. In that class, we look at surfaces and graphs of functions of two variables. We talk about things like traces and level curves for these objects. I decided I wanted to try 3D printing them.

My approach was to use VS Code for typing the OpenSCAD code. I didn’t know if this would work, but it worked very well. I had the file open in OpenSCAD; when I made an edit in VS Code, it automatically updated in OpenSCAD. Perfect. Then, I used GitHub Copilot in the sidebar as a coding assistant. It was hugely helpful.

Below are some examples of the objects I created. All the OpenSCAD code is available on my GitHub page. The code can generate

• The complete solid
• Traces for x=constant, y=constant, and z=constant with supporting structures so they stay together.
• One slice at a time, with slots in them, and a stand with slots in them, so they can be assembled and disassembled.

There are a variety of parameters you can tinker with to get the design exactly the way you want it. These objects printed very well, with the exception of the z=constant traces. Because the traces are horizontal, I had to turn the object 90°. But the slicer still had to add substantial support to get the object to print. They did print, but the edges where the supports were attached were a little ragged.

One lovely example is the following problem about tiling a grid with “trominoes” (three squares joined in an el-shape).

Prove that for any n ≥ 1, a 2ⁿx2ⁿ grid with one square removed can be tiled by trominoes.

Below we see 16×16 grid with one square removed. It is not too difficult to tile it with trominoes. The question is, how can you prove that it is always possible? We’ll leave that as an exercise.

This semester, I decided to laser cut some pieces so a student could play around with the tiles and to test conjectures. It consists of two layers of wood. The lower layer has the four grids (2×2, 4×4, 8×8, and 16×16). The top layer has the text and square holes for each of the puzzles. I also created four dark squares and enough tromino pieces to fill the board.

To play, choose one of the boards and place a dark square in any square in the grid. Then fill the board with trominoes (ideally, using an algorithm that would generalize to a proof that works for any size board).

Here are some completed puzzles.

If you want to laser-cut your own, here are downloadable pdfs (page 1 and page 2), also shown below. Note that when laser-cutting, the blue lines should be cut lines, the red lines are filled areas, and the green are etched lines.

The conjecture is easy to understand, although we need a few definitions first.

(Mathematical) knot: We can think of a mathematical knot as a loop of string sitting in three-dimensional space. In other words, if we took a piece of string, tied a knot, and then glued the two ends together, we’d get a mathematical knot.

Knot projection: Given any mathematical knot, we draw a two-dimensional version of it in the plane. It is like the shadow of the knot, but with breaks in the knot to indicate which strand is on top and which is on the bottom.

Unknotting number: If we have the projection of a knot, we can change some crossings (change which strand is over and which is under) to make it unknotted (called the unknot). To compute the unknotting number of a knot K, u(K), we look at all possible projections and find the fewest number of crossing changes we must make to obtain the unknot.

Connected sum: Given two knots, J and K, we can cut each knot at one point and join the cut ends to form a new, larger knot, J#K. This is called the connected sum of the knots.

Below, we see a knot called the (2,7) torus knot and its mirror image (left), and their connected sum on the right.

Although unknotting numbers are notoriously difficult to compute, we know that the unknotting number of a (p,q) torus knot is (p-1)(q-1)/2. So, the (2,7) torus knots above have unknotting number (2 – 1)(7 – 1)/2 = 3. It is not difficult to check that by changing three crossings of the projections shown above, the (2,7) torus knot becomes the unknot. It turns out that changing two crossings does not suffice in this projection or any projection.

Likewise, changing 3 + 3 = 6 crossings of the connected sum will yield the unknot. In fact, it will always be the case that u(J#K) ≤ u(J) + u(K). The question is: are these equal? An “old” conjecture (which was implicit in an article 88 years ago), states:

Conjecture: If J and K are knots, then u(J#K) = u(J) + u(K).

In their preprint, Brittenham and Hermiller disprove the conjecture by giving a counterexample! Moreover, the counterexample is precisely the one I’ve shown above! The connected sum of the torus knot with its mirror image has unknotting number 5, which is clearly less than 3 + 3.

That said, we can’t simply change the five crossings in the above projection to obtain the unknot. We must produce a different projection first. But what is it?

I looked for the answer online and found this arXiv preprint by Chao Wang and Yimu Zhang, which gives the details. They provide the projection and the crossings that must be changed. However, the projection has 56 crossings (far more than the original 14!). They assert, but do not show, that the resulting knot—after the five crossings are changed—is the unknot. They end by writing, “We prefer to leave it to the readers as an interesting game.”

Never good at resisting a good nerd sniping, I decided to take them up on the challenge. I’m embarrassed to admit how long it took me to confirm their work, but I did it. Here is my redrawn version of the knot projection—the connected sum of the (2,7) torus knot and its mirror image. The circled crossings are the five that must be changed.

After having done so, here’s the resulting projection. Wang and Zhang claim that it is the unknot!

Without further ado, here are my drawings. This first sequence shows how I get from the usual projection of the connected sum to the projection in which the crossings must be made. The red strands show the part of the projection that has changed from the previous projection.

Thus, the final image above is the knot we claim is the unknot. The following sequence of steps shows that it is indeed the unknot.

Ta da!!!

(I actually asked ChatGPT to assemble this list. It did an OK, but not great, job. About 70% of the links were correct. It hallucinated the rest, which all gave 404 errors or sent me to some unrelated page at the college. So, I had to find those the “old fashioned” way—using Google.)

• Agnes Scott College: https://www.agnesscott.edu/mathematics/
• Allegheny College: https://sites.allegheny.edu/math/
• Amherst College: https://www.amherst.edu/academiclife/departments/mathematics-statistics
• Bard College: https://math.bard.edu/
• Barnard College: https://math.barnard.edu/
• Bates College: https://www.bates.edu/mathematics/
• Berea College: https://www.berea.edu/mat/
• Bowdoin College: https://www.bowdoin.edu/math/
• Bryn Mawr College: https://www.brynmawr.edu/math
• Bucknell University:  https://www.bucknell.edu/academics/college-arts-sciences/academic-departments-programs/mathematics
• Carleton College: https://www.carleton.edu/math/
• Centre College: https://www.centre.edu/academics/majors-minors-programs/mathematics
• Claremont McKenna College: https://www.cmc.edu/math
• Colby College: https://www.colby.edu/mathematics/
• Colgate University: https://www.colgate.edu/academics/departments-programs/department-mathematics
• College of St. Benedict: https://www.csbsju.edu/mathematics
• College of the Holy Cross: https://www.holycross.edu/academics/programs/mathematics-and-computer-science
• College of Wooster: https://www.wooster.edu/academics/areas/mathematics/
• Colorado College: https://www.coloradocollege.edu/academics/dept/mathcs/
• Connecticut College: https://www.conncoll.edu/departments/mathematics/
• Davidson College: https://www.davidson.edu/academic-departments/mathematics-and-computer-science
• Denison University: https://denison.edu/academics/mathematics
• DePauw University: https://www.depauw.edu/academics/departments-programs/mathematics/
• Dickinson College: https://www.dickinson.edu/homepage/117/mathematics
• Earlham College: https://earlham.edu/academics/programs/mathematics/
• Franklin and Marshall College: https://www.fandm.edu/mathematics
• Furman University: https://www.furman.edu/academics/mathematics/
• Gettysburg College: https://www.gettysburg.edu/academic-programs/mathematics/
• Grinnell College: https://www.grinnell.edu/academics/majors-concentrations/math
• Gustavus Adolphus College: https://gustavus.edu/academics/departments/mathematics-computer-science-and-statistics/
• Hamilton College: https://www.hamilton.edu/academics/departments/faculty?dept=Mathematics
• Harvey Mudd College: https://www.hmc.edu/mathematics/
• Haverford College: https://www.haverford.edu/mathematics-and-statistics
• Hobart and William Smith Colleges: https://www.hws.edu/academics/mathematics/
• Kalamazoo College: https://mathematics.kzoo.edu
• Kenyon College: https://www.kenyon.edu/academics/departments-and-majors/mathematics-statistics/
• Lafayette College: https://math.lafayette.edu/
• Lake Forest College: https://www.lakeforest.edu/academics/majors-and-minors/mathematics
• Lawrence University: https://www.lawrence.edu/academics/college/mathematics
• Macalester College: https://www.macalester.edu/mscs/
• Middlebury College: https://www.middlebury.edu/college/academics/mathematics
• Mount Holyoke College: https://www.mtholyoke.edu/acad/math
• Muhlenberg College: https://www.muhlenberg.edu/academics/mathcs/mathematics/
• Oberlin College and Conservatory: https://www.oberlin.edu/arts-and-sciences/departments/mathematics
• Occidental College: https://www.oxy.edu/academics/areas-study/mathematics
• Pitzer College: https://www.pitzer.edu/academics/programs/mathematics
• Pomona College: https://www.pomona.edu/academics/departments/mathematics-statistics
• Principia College: https://www.principiacollege.edu/academics/majors/mathematics
• Reed College: https://www.reed.edu/math/
• Rhodes College: https://www.rhodes.edu/academics/majors-minors/mathematics-statistics
• Scripps College: https://www.scrippscollege.edu/departments/mathematics
• Sewanee: The University of the South: https://new.sewanee.edu/programs-of-study/mathematics/
• Skidmore College: https://www.skidmore.edu/mathematics/index.php
• Smith College: https://www.smith.edu/academics/mathematical-sciences
• Soka University of America: https://www.soka.edu/academics/ikeda-college-undergraduate-studies/general-education-curriculum/science-and-1
• Spelman College: https://www.spelman.edu/academics/majors-and-programs/mathematics
• St. Lawrence University: https://www.stlawu.edu/offices/math-computer-science-and-statistics
• St. Olaf College: https://wp.stolaf.edu/math/
• Swarthmore College: https://www.swarthmore.edu/mathematics-statistics
• Thomas Aquinas College: https://www.thomasaquinas.edu/a-liberating-education/why-we-study/why-we-study-mathematics
• Trinity College: https://www.trincoll.edu/mathematics/
• Trinity University: https://www.trinity.edu/academics/departments/mathematics
• Union College: https://www.union.edu/mathematics
• United States Air Force Academy: https://www.usafa.edu/academic/mathematics/
• United States Military Academy: https://www.westpoint.edu/academics/academic-departments/mathematical-sciences
• United States Naval Academy: https://www.usna.edu/MathDept/
• University of Richmond: https://math.richmond.edu/
• Vassar College: https://www.vassar.edu/math
• Virginia Military Institute: https://www.vmi.edu/academics/departments/applied-mathematics/
• Wabash College: https://www.wabash.edu/academics/math
• Washington and Lee University: https://www.wlu.edu/mathematics-department/
• Wellesley College: https://www.wellesley.edu/math
• Wesleyan University: https://www.wesleyan.edu/math/
• Wheaton College (IL): https://www.wheaton.edu/academics/departments/mathematics-and-computer-science/mathematics/
• Wheaton College (MA): https://wheatoncollege.edu/academics/departments/mathematics/
• Whitman College: https://www.whitman.edu/academics/departments-and-programs/mathematics
• Willamette University: https://willamette.edu/undergraduate/math/
• Williams College: https://math.williams.edu/
• Wofford College: https://www.wofford.edu/academics/majors-and-programs/mathematics

Here are two versions—a small version that may be better on a phone and a large version that may be better on a larger screen.

For Christmas, my son made me a mechanical keyboard. It was so thoughtful—a solid keyboard base with high-quality switches and elegant keycaps. There are many ways to customize the keyboard. I asked him if it was possible to enable it to type Greek letters and other mathematical notation using various key combinations. He looked into it and found a fantastic method that should work for any keyboard (on a Mac).

Basically, you create a text file called DefaultKeyBinding.dict and put it in a folder called Keybindings in your Library. (In the Finder, select the “Go” menu while pressing the option key. You’ll see you can open your Library. In it, create the Keybindings folder and put your text file in there.) For it to take effect in an app you’re using, you need to restart the app after modifying the dict file.

The text file could look something like this:

{
// double slashes indicate comments
"~#2" = (insertText:, "\U2082"); // option-2 on the number pad will produce the subscript 2
"~$#2" = (insertText:, "\U00B2"); // option-shift-2 on the nubmer pad will produce superscript 2
"~t" = (insertText:, "\U03B8"); // option-t produces a theta
"~$D" = (insertText:, "\U0394"); // option-shift-D will produce a capital delta
"~$E" = (insertText:, "\U2203"); // option-shift-E will produce the "there exists" symbol 
}

As you should be able to tell, the first part of each line tells what modifier keys you need to press along with the key on the keyboard. They are
~ : option
$ : shift
^ : control
@ : command
# : numpad
The output is the Unicode for the desired symbol. I found this Wikipedia page helpful in finding the Unicode for my desired characters.

I created key combinations that type many of the Greek letters in lower case, some of them capitalized, basic set notation (intersection, union, subset, element of, etc.), the “blackboard bold” notation for sets of numbers (like the real numbers and the integers), and so on. I created a way to get superscripts and subscripts by using the option key or shift-option and typing on the number pad.

Finally, I made a cheat sheet to help me remember what’s where on my keyboard.

In case you are interested, here’s the file I created. (I tried to upload the file so it could be downloaded, but this blogging platform did not allow me to do so. You’ll have to copy and paste this into your own text file.) There were a few that didn’t work for me—like remapping option-shift-#—I suspect that there is some escape code that would make it work, but I didn’t look into it.

{
  // Save as ~/Library/KeyBindings/DefaultKeyBinding.dict
  // ~ : option
  // $ : shift
  // # : numpad
  // ^ : control
  // @ : command
  // helpful website: https://en.wikipedia.org/wiki/Apple_Symbols


  // subscript (option + numpad 0-9)
  "~#0" = (insertText:, "\U2080"); // subscript 0 ₀
  "~#1" = (insertText:, "\U2081"); // subscript 1 ₁
  "~#2" = (insertText:, "\U2082"); // subscript 2 ₂
  "~#3" = (insertText:, "\U2083"); // subscript 3 ₃
  "~#4" = (insertText:, "\U2084"); // subscript 4 ₄
  "~#5" = (insertText:, "\U2085"); // subscript 5 ₅
  "~#6" = (insertText:, "\U2086"); // subscript 6 ₆
  "~#7" = (insertText:, "\U2087"); // subscript 7 ₇
  "~#8" = (insertText:, "\U2088"); // subscript 8 ₈
  "~#9" = (insertText:, "\U2089"); // subscript 9 ₉


  // superscript (option + shift + numpad 0-9)
  "~$#0" = (insertText:, "\U2070"); // superscript 0 ⁰
  "~$#1" = (insertText:, "\U00B9"); // superscript 1 ¹
  "~$#2" = (insertText:, "\U00B2"); // superscript 2 ²
  "~$#3" = (insertText:, "\U00B3"); // superscript 3 ³
  "~$#4" = (insertText:, "\U2074"); // superscript 4 ⁴
  "~$#5" = (insertText:, "\U2075"); // superscript 5 ⁵
  "~$#6" = (insertText:, "\U2076"); // superscript 6 ⁶
  "~$#7" = (insertText:, "\U2077"); // superscript 7 ⁷
  "~$#8" = (insertText:, "\U2078"); // superscript 8 ⁸
  "~$#9" = (insertText:, "\U2079"); // superscript 9 ⁹


  // option + letter
//  "~1" = (insertText:, ""); // 
//  "~2" = (insertText:, ""); // 
//  "~3" = (insertText:, ""); // 
//  "~4" = (insertText:, ""); // 
//  "~5" = (insertText:, ""); // Leave alone---infinity ∞
//  "~6" = (insertText:, ""); // 
//  "~7" = (insertText:, ""); // 
//  "~8" = (insertText:, ""); // Leave alone---bullet symbol •
//  "~9" = (insertText:, ""); // 
//  "~0" = (insertText:, ""); // 
//  "~-" = (insertText:, ""); // Leave alone---en-dash –
//  "~=" = (insertText:, ""); // Leave alone---not equal ≠
  "~a" = (insertText:, "\U03B1"); // α
  "~b" = (insertText:, "\U03B2"); // β 
  "~c"  = (insertText:, "\U03B5"); // ε
  "~d" = (insertText:, "\U03B4"); // δ
//  "~e" = (insertText:, ""); // Leave alone---produces the acute accent
  "~f" = (insertText:, "\U03C6"); // φ  
  "~g" = (insertText:, "\U03B3"); // γ
  "~h" = (insertText:, "\U03B7"); // η
//  "~i" = (insertText:, ""); // Leave alone---produces an accent
  "~j" = (insertText:,  "\U03C4"); // τ
  "~k" = (insertText:, "\U03BA"); // κ
  "~l" = (insertText:, "\U03BB"); // λ
  "~m" = (insertText:, "\U03BC"); // μ
//  "~n" = (insertText:, ""); // Leave alone---produces an accent
//  "~o" = (insertText:, ""); // 
  "~p" = (insertText:, "\U03C0"); // π 
  "~q" = (insertText:, "\U03BE"); // ξ 
  "~r" = (insertText:, "\U03C1"); // ρ
  "~s" = (insertText:, "\U03C3"); // σ
  "~t" = (insertText:, "\U03B8"); // θ
//  "~u" = (insertText:, ""); // Leave alone---produces the umlaut
  "~v" = (insertText:,"\U03BD"); // ν
  "~w" = (insertText:, "\U03C9"); // ω
  "~x" = (insertText:, "\U03C7"); // χ
  "~y" = (insertText:, "\U03C8"); // ψ
  "~z" = (insertText:, "\U03B6"); // ζ
//  "~`" = (insertText:, ""); // Leave alone---produces an accent
  "~[" = (insertText:,  "\U2229"); // intersection ∩ 
  "~]" = (insertText:,  "\U222A"); // union ∪ 
//  "~\" = (insertText:, ""); // 
//  "~;" = (insertText:, ""); // 
//  "~'" = (insertText:, ""); // 
//  "~," = (insertText:, ""); // Leave alone---produces less than or equal to ≤
//  "~." = (insertText:, ""); // Leave alone---produces greater than or equal to ≥
//  "~/" = (insertText:, ""); // Leave alone---produces the division symbol ÷


// option + shift + letter
//  "~$~" = (insertText:, ""); //  leave alone---causes an error
  "~$!" = (insertText:, "\U2248"); //  ≈ 
//  "~$@" = (insertText:, ""); //  leave alone---causes an error
//  "~$#" = (insertText:, ""); //   leave alone---causes an error
//  "~$$" = (insertText:, ""); //   leave alone---causes an error
  "~$%" = (insertText:, "\U222B"); //  ∫ 
//  "~$^" = (insertText:, ""); //  leave alone---causes an error
  "~$&" = (insertText:, "\U221A"); //  √ 
//  "~$*" = (insertText:, ""); // Leave alone---degree symbol °
  "~$(" = (insertText:, "\U27E8"); // left angle bracket ⟨ 
  "~$)" = (insertText:, "\U27E9"); // right angle bracket ⟩
//  "~$_" = (insertText:, ""); // Leave alone---em-dash —
//  "~$+" = (insertText:, ""); // Leave alone---plus-minus ±
  "~$A" = (insertText:, "\U2200"); // for all ∀
  "~$B" = (insertText:, "\U2135"); // Alef ℵ 
  "~$C" = (insertText:, "\U2102"); // Complex numbers ℂ
  "~$D" = (insertText:, "\U0394"); // Delta Δ
  "~$E" = (insertText:, "\U2203"); // there exists ∃ 
  "~$F" = (insertText:, "\U220A"); // element of ∊
  "~$G" = (insertText:, "\U0393"); // Gamma Γ
  "~$H" = (insertText:, "\U2190"); // left arrow ← 
  "~$I" = (insertText:, "\U2194"); // double arrow ↔ 
  "~$J" = (insertText:, "\U21D0"); // double left arrow ⇐
  "~$K" = (insertText:, "\U21D2"); // doubleright arrow ⇒ 
  "~$L" = (insertText:, "\U2192"); // right arrow →
  "~$M" = (insertText:, "\U2193"); // down arrow ↓ 
  "~$N" = (insertText:, "\U2115"); // Natural numbers ℕ 
  "~$O" = (insertText:, "\U2207"); // nabla (gradient) ∇ 
  "~$P" = (insertText:, "\U2119"); // Projective plane ℙ
  "~$Q" = (insertText:, "\U211A"); // Rational numbers ℚ
  "~$R" = (insertText:, "\U211D"); // Real numbers ℝ 
  "~$S" = (insertText:, "\U03A3"); // Σ
//  "~$T" = (insertText:, ""); // 
  "~$U" = (insertText:, "\U2191"); // up arrow ↑ 
  "~$V" = (insertText:, "\U2209"); // not an element of ∉
//  "~$W" = (insertText:, ""); // 
  "~$X" = (insertText:, "\U2A2F"); // times/cross product ⨯
//  "~$Y" = (insertText:, ""); // 
  "~$Z" = (insertText:, "\U2124"); // Integers ℤ 
  "~${" = (insertText:, "\U2227"); // and ∧
  "~$}" = (insertText:, "\U2228"); // or ∨ 
//  "~$|" = (insertText:, ""); // 
  "~$:" = (insertText:, "\U039B"); // Gamma Λ
//  "~$"" = (insertText:, ""); // 
//  "~$:" = (insertText:, ""); //  
//  "~$"" = (insertText:, "\U2228"); // Leave alone---causes an error
  "~$<" = (insertText:, "\U2286"); // subset ⊆ 
  "~$>" = (insertText:, "\U2287"); // supset ⊇ 
//  "~$?" = (insertText:, ""); // 
}

In this post, I show how you can create your own “Magic Eye” image using Excel. (I also give you an Excel spreadsheet to get you started.) Technically these images are called autostereograms. These are two-dimensional images that appear three-dimensional when viewed correctly with your two eyes. Here are some tips for viewing these images.

1. Relax your eyes.
2. Let your eyes diverge. Look through the image as if it’s a window, and you are focusing on something beyond it.
3. If there are similar patterns in the pixels, allow them to come together as one in your vision.

Here’s one example I made. You shoud see a flat background with one large copy of the letter π floating a little above the background (closer to you). I have several other examples at the end of this post. (These all work better on a larger screen—not on a phone screen.)

I’ll now share how I made these images and give you enough details to make your own. If you want to make your own, download this Excel file, which has my sample code in it.

The Excel file has three tabs at the bottom: the “Final” tab has the final image, the “Raw” tab contains the depth map for the image you’d like to create, and the “Parameters” tab allows you to adjust three parameters.

Raw tab. This tab contains the 300×300 “depth map” for the desired 3D image. In my π example above, there are only two depths—the background (corresponding to 0 in the cell) and the π in the foreground (1). If you want to design a more complex shape with more depth, you can have different values in the cells (they do not have to be integers). For instance, two of the images below show undulating surfaces with varrying depths.

I used ChatGPT to help create the depth map for π. First, I created the image shown below with a black π on a white background. I then uploaded it to ChatGPT and typed the following prompt.

I am uploading a square black and white image. I would like a csv file with 300 rows and 300 columns that shows this image. In particular, I would like you to imagine shrinking this down to a 300x300 image, and then converting the white pixels to be 0 and the black pixels to be 1. 

For the two images showing surfaces, I begain with a top row and a left column that gave a sequence of points along the x- and y-axes, respectively. Then, I created a formula in each cell that evaluated a function at the corresponding x and y values. Here’s the code in cell B2 for one example.

=SIN(SQRT(B$1^2+$A2^2))/SQRT(B$1^2+$A2^2)+1

Parameters tab. This tab allows you to enter three values that will change the look of the final image: numcolors, backshift, and multfactor.

Final tab. The “Final” tab contains the final image. To view this page, you want to zoom far enough out that the entire image is visible. You don’t have to edit this page at all. It is generated using the information you provide in the other two tabs.

This page is a 300×300 grid, and each cell contains a number 1 through numcolors. Excel’s “conditional formatting” colors the page automatically based on the number. (You can change the colors by changing the conditional formatting for these cells.)

Each cell has code like the following. (This code is in cell A1.)

=LET(
depth,Raw!A1,
numcolors,Parameters!$B$1,
backshift,Parameters!$B$2,
multfactor,Parameters!$B$3,
pixelshift,TRUNC(backshift-depth*multfactor),
IF(
COLUMN()>backshift,
OFFSET(A1,0,-pixelshift),
RANDBETWEEN(1,numcolors)
)
)

Here’s what it does. The general idea is that we want our two eyes to see two different horizontally-separated pixels of the same color as one pixel. The closer together the pair of pixels, the nearer to you the combined pixels will seem when looking at the image with both eyes.

For the first backshift number of columns, the code randomly assigns a number (which we think of as a color): 1 through numcolors. For the rest of the columns, the color of a pixel is the same as the color of some pixel to its left. For points on the flat background (corresponding to a depth of 0), each pixel is the same color as the pixel backshift spaces to the left. My π example has backshift= 40. The pixels we want to appear closer to us should be closer together; in this code, such a pixel is the same color as the one backshift-depth*multfactor cells away. In our π example, we have multfactor= 4, so a depth of 1 yields a shift of

That’s it! Have fun playing. Here are some examples.

This one shows a familiar mathematical variable.

This one shows a familiar mathematical symbol.

This one shows a surface: the graph of a multivariable function.

This one shows a surface: the graph of a multivariable function.

This one shows one of our earlier symbols again. I changed the pattern for the first few columns. That gave this repeating look.

This one shows one of our earlier symbols again. I changed the pattern for the first few columns. That gave this repeating look.

An introduction to the Mandelbrot set

First, let’s explain what the Mandelbrot set is. We begin with a family of functions with complex numbers as inputs and outputs. Let be a complex number (a parameter). Define the function by

Given a starting value, a complex number (called the seed), we plug it into the function to get Then, plug the output back in the new output back in and so on, to get a sequence of complex numbers, called the orbit of

For instance, suppose our parameter is and we begin with the seed Then, the orbit is

What you’ll find if you play with this function for a while is that some orbits go off to infinity while others remain bounded. A bounded orbit might be periodic, might get closer to some periodic orbit, or might behave chaotically.

The Mandelbrot set is a subset of the set of parameter values. Some parameter values are in the Mandelbrot set, and some are not. To test whether a parameter is in the Mandelbrot set, we focus on the orbit of 0. If the orbit of 0 remains bounded, our parameter is in the Mandelbrot set. If the orbit of 0 goes off to infinity, is not in the Mandelbrot set.

In our example with parameter the orbit of of 0 is This orbit eventually lands on a period-2 orbit. So, the orbit is bounded, and is in the Mandelbrot set. On the other hand, with the parameter the orbit of 0 is This orbit goes to infinity, so 1 is not in the Mandelbrot set.

If you want to draw the Mandelbrot set on a computer, you can think of your display screen as the complex plane. Each pixel represents a complex number The value corresponds to a column and the value corresponds to a row. We view as the parameter for the function Compute the first terms in the orbit of 0 (you will have to decide on a good ). If the orbit gets farther than units away from the origin (you will have to decide on a good ), then is not in the Mandelbrot set; color it white. If it does not go that far away, it is likely in the Mandelbrot set; color it black.

That’s it!

If you want those stunning pictures in which the black Mandelbrot is surrounded by a beautiful, colorful gradient, you have to do a little more work, although not much more. For the points not in the Mandelbrot set, keep track of when the orbit gets farther than units away from the origin. Does it get that far away after 5 steps? 10 steps? 50 steps? Color the pixel based on that exit time.

The Mandelbrot set in Excel

Yesterday, I had the idea of creating the Mandelbrot set using Excel. I could treat each cell as a complex number (the parameter ). In that cell, I could check whether the complex number is or is not in the Mandelbrot set. I could mark it with a 0 or 1 to indicate its status.

I’m handy with Excel, but I’m not a power user. I did not want to figure out how to come up with the code for this. I decided to ask ChatGPT for help. I began by placing the sequence in the first row and the sequnce in the first column. These values represented the and coordinates for the complex numbers in the square region of the spreadsheet.

After a little back-and-forth with ChatGPT, I got the following code, which uses and (I told ChatGPT exactly what I wanted it to do. It took a few tries because it was using variable names like z1, z2, etc., which Excel thought were references to cells in the spreadsheet.) This code goes in the cell B2, and similar code goes into the rest of the cells.

=LET(
c, COMPLEX(B$1, $A2),
a, COMPLEX(0, 0),
b, IMSUM(IMPOWER(a, 2), c),
d, IMSUM(IMPOWER(b, 2), c),
e, IMSUM(IMPOWER(d, 2), c),
f, IMSUM(IMPOWER(e, 2), c),
g, IMSUM(IMPOWER(f, 2), c),
h, IMSUM(IMPOWER(g, 2), c),
i, IMSUM(IMPOWER(h, 2), c),
j, IMSUM(IMPOWER(i, 2), c),
k, IMSUM(IMPOWER(j, 2), c),
IF(IMABS(k) > 10,0,1)
)

Even if you don’t know Excel, you may be able to read and understand this code. It creates the complex number from the entries in the left-most column and the top row, starts with the complex value 0, iterates it to get an orbit of length 10, checks to see if the last term is greater than 10, and then spits out a 0 (yes) or 1 (no). Below, you see the resulting output (I adjusted the row and column sizes so the cells were approximately square). Pretty good!

Once I saw that this proof of concept was successful, I started improving the design. For instance, I did the following. (I did some of this myself, as I’m familiar with some of Excel’s commands, and I asked ChatGPT for help with other parts.)

• I increased the size of my canvas (so the difference between the values was much smaller).
• I stopped the computation once the output value was larger (in modulus) than the chosen value.
• I had the algorithm look at predetermined cells to find the and values. This allowed me to change them globally by changing a single value.
• Rather than putting a 0 or 1 in the cell, I had it put a period (.) for points in the Mandelbrot set and the number of steps required to become larger than in modulus for points outside the Mandelbrot set.
• This last choice allowed me to add some color. If the cell had a period in it, I colored it black. If the cell contained a number, I had Excel’s conditional formatting color it. My settings are shown below.

Below, you’ll see the resulting Mandelbrot sets in a 30×30, 60×60, and 250×250 grid. For the largest one, I had to zoom out very far. Pretty amazing, right?

In the end, the code was pretty short. Here is the final code for cell B2 (the other cells are very similar). There was a lot of back and forth with ChatGPT to get it to do what I wanted it to do. I don’t think it could have worked if I wasn’t both familiar with the mathematics behind the Mandelbrot set and comfortable working with Excel. Still, I did not write this code. I was done largely by ChatGPT.

=LET(
c, COMPLEX(B$1, $A2),
threshold, Parameters!$B$5,
maxIterations, Parameters!$B$6,
zArray, SCAN(
COMPLEX(0, 0),
SEQUENCE(maxIterations),
LAMBDA(prevZ,i, IF(IMABS(prevZ) > threshold, prevZ, IMSUM(IMPOWER(prevZ, 2), c)))
),
exceedIndex, XMATCH(TRUE, IMABS(zArray) > threshold, 0),
IF(ISNUMBER(exceedIndex), exceedIndex, ".")
)

The last thing I did was to create a way to zoom in on specific areas of the Mandelbrot set. To do so, I created the following additional parameters:

• Center point (real part)
• Center point (imaginary part)
• Width of the region (this is also the height of the region)

I used these to compute the minimum real value, the maximum imaginary value, and the step size between rows and columns. I used this information to generate the numbering along the top and left of the spreadsheet.

Here are a few of the resulting images. Remember, these are all in Excel! (If you look closely, you can see some black dots—those are the numbers in the cells.)

If you want to play with this, download the Excel file. Enter the parameters in the colored cells on the first tab. Then, view the resulting images in the other three tabs. Below are the parameters for the full Mandelbrot set. On the first tab of the spreadsheet, I’ve also included the parameters for the images shown above. Enjoy!

I decided to finish the trifecta: here’s a template to fold and cut a turtle tile.