Visualizer ideas

[gwhitney]

It turns out that some interesting visualizer ideas have been lost by virtue of being stored in a message system in which messages expired after a certain period of time, so I am opening this discussion as a place to record possible concepts for new visualizers.

[gwhitney]

"Kepler-Brouwkamp visualizer". At least when each a_i >= 3, we can inscribe/circumscribe a regular polygon with a_i sides in/around the circle so far, and then in/circumscribe a circle around that, and continue in this fashion with a_{i+1} and so on. For a_i = i, this produces a diagram with limiting circle radius determined by the Kepler-Brouwkamp constant. Other sequences would have no limit, or a different limit. In addition, the vertices of the successive polygons produce interesting curves/moirés.

[gwhitney]

A variation suggested by Tom Edgar: draw a regular i-gon at a radius determined (in some way) by a_i.

[gwhitney]

We could have a visualizer that plays the abelian sandpile game, using the sequence values (I guess in pairs to determine x and y coordinates) to determine where to place the next grain of sand, on either a finite or infinite board. If we wanted to avoid using the sequence values in pairs, we could use a board that is finite vertically but infinite horizontally, and place all grains on the y-axis, with y-coordinates given by successive sequence values.

[katestange]

Pretty picture (just showing evens/odds) https://www.reddit.com/r/math/comments/1682g0o/amazing_pattern_in_a_sequence_i_found_whiteodd/?share_id=G4HTTVOQK5PxFBpODwdEL&utm_content=2&utm_medium=android_app&utm_name=androidcss&utm_source=share&utm_term=10

[gwhitney]

A variation on the grid visualizer that uses the fibonacci-voronoi/sunflower-seed cells, e.g. https://www.neatoshop.com/product/Fibonacci-modulus.

[gwhitney]

Tree-branching visualizer: start with a root, it has a_1 children; its first child has a_2 children; its next child has a_3 children. When the children are exhausted, start going through the grandchildren breadth-first, each time using the next sequence entry to control the number of children. (Maybe have to use some graph layout software, or just compute the number in each generation and lay them out in successively larger circles, equally spaced at each generation.)

[Vectornaut]

Given a series $a_0, a_1, a_2, a_3, ...$, plot the power series $a_0 + a_1 z + a_2 z^2 + a_3 z^3 + \ldots$.

A fragment shader might be the most natural way to do this. (Is there a built-in way to use a fragment shader in a visualizer already?) We'd need to estimate the radius of convergence.

[gwhitney]

Nice. I assume you mean the function from ${\mathbb C} \to {\mathbb C}$ represented by the power series? As two side-by-side surfaces, one showing the modulus and the other the argument of the values? Or did you have some other picture in mind?

[Vectornaut]

Plot the Borel sum of a series.

[gwhitney]

You mean this: https://en.wikipedia.org/wiki/Borel_summation ? Same kind of picture as for the direct power series?

[Vectornaut]

Yup, that's the one.

[gwhitney]

Might we possibly also be interested in visualizing just the Borel transform of the sequence, i.e. the function ${\mathbb R} \to {\mathbb R}$ given by

$$\sum_{k=0}^\infty \frac{a_k}{k!} t^k \quad ?$$

[Vectornaut]

I think of the Borel transform as a series transformation. If there's a facility for composing visualizers with transformations (like Grasshopper components), it would belong there. Then you could visualize it by composing the Borel transform with the power series visualizer.

[gwhitney]

That makes sense. So I guess that means the question is: Should a potential power series visualizer also have a mode in which it shows only the $\mathbb{R} \to \mathbb{R}$ part of the function defined by the power series?

[katestange]

Here's something that visualizes hitomezashi patterns, it's a type of visualizer of sequences: https://github.com/dwildstr/hitomezashi-explorer

[gwhitney]

There are two visualizers implicit in this page: https://puzzlezapper.com/aom/mathrec/sequences.html. The first seems to be identical to our triangle of a series mod different numbers. If so, we could have this in our presets; might be nice to be able to add external reference links to presets. The second like our existing turtle graphics visualizer, except that it allows assignment of any turtle instruction to a given sequence value, which I don't think our turtle visualizer currently allows. Would be nice to extend it.

[katestange]

INDEX = TIME screen filling visualizing. This visualizer uses the index as time: https://chengsun.uk/lcg.html The sequence lives modulo the number of pixels. At each time step, the value of the sequence at that index/time corresponds to one position on the screen (value = position reading top to bottom, left to right; or, left to right, top to bottom). The corresponding pixel is filled. The sequence in question here is periodic, so when it hits zero, the colour of filling rectangles is swapped between black and white, and the coordinate axes are swapped. So it fills white reading one way until a period finishes, and then fills black reading the other.

[katestange]

one cool thing about this one is that it has some of the same patterns seen in the distance visualizer (in my prototypes) for quadratic type congruence sequences: is neat to "recognize" the same pattern across two totally different situations.

[gwhitney]

OK, let's see if I understand. The user of the visualizer sets a length and width of a rectangle to serve as a visualization area, so that it has A cells. The cells all start out white. The user selects an order on the rectangle: row-major or column-major. That results in a numbering of the cells from 0 to A-1. Sequence values are taken modulo A. At each time step t, the (a(t) % A)th cell is flipped from white to black or black to white. Is that it? Sounds nice. Perhaps there should be a speed control as well. And of course, we could allow cycling among more that two fill colors for the cells...

[katestange]

Yup, that's right. I think a gradual fading on cells after they are turned on is another way to represent time nicely.

[katestange]

I don't really understand what's going on here, but it looks interesting: https://www.researchgate.net/figure/Four-Ripleys-plots-generated-using-a-linear-congruential-generator-followed-by-the_fig18_311805850 keyword: Box-Muller Transform

[gwhitney]

Hmm, I glanced through the paper and read the Wikipedia page on Box-Muller. I am not really certain what is going on either, but my current guess is something like this: Convert the sequence into a sequence of rational numbers in [0,1) by choosing a modulus and taking each entry's residue in that modulus divided by the modulus. Taken successively in pairs, you could plot each such pair in the unit square (that would I guess by itself be a possible visualizer). But the Box-Muller transform takes a random point uniformly distributed in the unit square to a point bivariate-normally distributed about the origin. So plot those transformed points. I think that would produce the four plots shown in the paper.

[gwhitney]

Variation on chaos visualizer, was #248:
This is a slight variation on the chaos game: it would be easy to set the chaos visualizer to allow such an option:

https://twitter.com/matthen2/status/1268808515574886407

On the Illustrating Mathematics discord server, user peteok [Peter Kagey, at Cal Poly Pomona as of Fall 2024] did this with a square using various types of triangle centres from Clark Kimberling's Encyclopedia of Triangle Centers and it produced very interesting and beautiful results!

Indeed, and if we wanted to allow the choice of various centers, I think this might be meaty enough for its own visualizer rather than shoehorning it into the existing chaos visualizer...

[katestange]

An idea would be to play games on arbitrary sequences that are usually played on the integers. So for example, here's a game, called Sylver coinage made into a web app. One tricky aspect of that example is that it is actually played on the infinite sequence of positive integers. However, one could imagine adaptations to finite sequences (which is all we can assume we get from the OEIS!). One thing about this idea is that it would be a very interactive visualizer, if the user is playing a game against the computer for example.

[katestange]

Here's an interesting idea for a visualizer based on a sequence: https://open.substack.com/pub/apieceofthepi/p/how-to-solve-any-maze-using-the-digits?r=semnj&utm_campaign=post&utm_medium=email

[gwhitney]

Nice. If we were putting this into numberscope, there would be a question of how to generate the maze to be solved. It would be nice if there were a sensible "Maze Visualizer" that would generate a maze from a sequence and then the link above suggests the "Maze-Solver Visualizer" and ideally at some point we'd be able to combine the two, and you could see which sequences were good at/poor at solving the mazes generated by other sequences...

[katestange]

Discussion from the Illustrating Math Discord concerned the sum-of-digits function, that might be an interesting thing to visualize. The specific suggestion was a square visualization with sum(x)+sum(y)+sum(x+y). But one could more generally take any function of interest f() on any sequence of interest s_n and do various combos of f(s_x) and f(s_y) or more like f(s_x+s_y)-- this suggests a very general visualizer where the user can basically input a formula for pixel (x,y) in terms of the sequence at hand. This would be pretty versatile, but require some creativity on the part of the user. Kind of like a shader in a way. Maybe this is sort of where the grid visualizer is headed....

[gwhitney]

To make sure I am following, you are mapping this scheme onto this IllusMath Discord by thinking of the sum-of-binary-digits as the sequence s_n (= A000120, as it happens), and your function f as parity, and then plotting f(s_x + s_y + s_{x+y}) (as black or white) ?

I agree it's sort of like the Grid visualizer, except that the Grid visualizer currently takes some injective function g(x,y) -> N and plots f(s_{g(x,y)}) at position (x,y) for any of a number of possible 'f's that it allows you to select from some canned list. As I've mentioned in discussions about Grid, it would be nice to allow f to be specified by a sequence/formula itself, rather than be canned. In particular, the original Ulam spiral is just isPrime(Identity_{g(x,y)}). Once we have achieved some level of unification of OEIS sequences with Formulas (so you can say e.g. A000040^2 for the squares of the primes), it will be easy to fold the f and s parts into the Sequence. And Grid already allows a few g(x,y) possibilities: the original spiral, starting from a different number than 0 in the center, spiraling in from the edge to the center instead of vice versa, scanning left-to-right on each line and then going down the page, maybe some others I have forgotten.

So the main thing that seems different about the Illustrating Math example and Grid as it stands is (a) allowing g(x,y) not to be injective (none of x, y, or x+y is), and (b) allowing a combination of multiple sequence entries based on different functions of the coordinates. That latter part (b) is what really doesn't fit smoothly into our current setup of Sequences vs Visualizers. In a world where we have arbitrary formulas in which OEIS designations can appear, though, one could just write the formula (A000120(x) + A000120(y) + A000120(x+y)) % 2 in a formula entry box and we could have a visualizer that just plots that on the lattice points (x,y) (by mapping the resulting value on (x,y) into an array of colors). That visualizer wouldn't really use a Sequence at all in the way we are using them now, but it would be quite powerful, really. However, I agree as you point out that the entry barrier to using that exact visualizer as just described would be quite high: it would just have this one big formula box, and a random person coming to it wouldn't really have any idea what to type in the box. It's almost too open-ended/powerful.

[katestange]

In a world where we have arbitrary formulas in which OEIS designations can appear, though, one could just write the formula (A000120(x) + A000120(y) + A000120(x+y)) % 2 in a formula entry box and we could have a visualizer that just plots that on the lattice points (x,y) (by mapping the resulting value on (x,y) into an array of colors).

Yup, this is exactly what I'm imagining. I agree it would be almost too powerful -- you'd want to hide it from casual visitors at first -- but I would LOVE to be able to play with it. It would almost be like desmos, where you could use it for many experiments or ideas you might have.

[katestange]

Something that may help with inspiration: https://arxiv.org/pdf/2209.09543. This is a paper that discusses the abstract "types" of integer sequences in the OEIS.

[gwhitney]

Also of interest is Sloane's 50th anniversary paper https://doi.org/10.1007/s00283-023010266-6

[katestange]

Visualizing fractal sequences: https://math.stackexchange.com/questions/1915048/what-methods-are-known-to-visualize-the-patterns-of-fractal-sequences

[katestange]

Any binary sequence makes a fractal: https://archive.bridgesmathart.org/2024/bridges2024-527.pdf

[gwhitney]

Nice! It's not 100% clear how to proceed with a conceptually infinite sequence: at each folding stage, do you start over from the beginning of the sequence and just use twice as much of it as the previous time? Or do you just pick up from where you left off? I guess we could try both. I think the author of the article restarted from the beginning each time, but it's not really explicit in the article (although it would be in the code).

Thinking about generalizing to sequences with more possible values, you could specify what segment replacement each sequence value corresponds to, from a larger palette of polygonal path options (the replacements could be given in turtle notation or something like that).

[gwhitney]

In some discussion, maybe at a meeting, Kate noted that the numbers of holes in the concentric rings of holes in a speaker grille often went something like https://oeis.org/A187352, the complement of the rank transform of $\lfloor n/\sqrt2 \rfloor$ (rank transforms are defined/discussed at https://oeis.org/A187224). This suggested a visualizer that consisted of making the corresponding speaker grille, which is potentially a variant of #264 (comment) but just drawing the vertices and making the circle radii linear in the index $n$ or perhaps linear in $\sqrt n$ (I guess the radii could be another input sequence?). And that then led to a question of which is better: fewer visualizers with lots of options, or more visualizers, each more closely focused on a particular style of visualization? (The answer could be that we want both, in some sense, I suppose.)

[gwhitney]

More visualizations along these same general lines (but in which the spacing around the concentric circles is part of the visualization, rather than always equispaced): see https://discord.com/channels/862052650208329739/872880923580989480/1275975871928467530

[katestange]

It was Aaron who pointed out the number of holes, btw.

[gwhitney]

On the ilustrating math discord someone posted a bicolor turtle-based visualization of primes and composites. Perhaps our turtle visualizer could be extended to cover this? I haven't studied it (posted as Python code) in detail...

[katestange]

Fourier analysis that picks up this interesting signal in the Ulam sequence: https://apieceofthepi.substack.com/p/ulam-words-and-the-ulam-sequence?utm_source=post-email-title&publication_id=1642488&post_id=149987428&utm_campaign=email-post-title&isFreemail=true&r=semnj&triedRedirect=true&utm_medium=email

[katestange]

paper on the topic: https://arxiv.org/abs/1507.00267

[gwhitney]

Network visualizer: Every sequence $a$ defines a directed network with vertices the set of integers by adding an edge from $n$ to $m$ exactly when $a_n = m$. This network, in its usual representation, is in fact precisely the graph of the function $a(n) = a_n$ in the set-theoretic sense of the word 'graph of a function', but considered as a directed network; is that perhaps the origin of using the term 'graph' for network, a usage that's so confusing to non-initiates at first? But I digress.) It could be interesting, e.g. for Collatz-related functions, to place all of these nodes and edges in a network-layout program and display the results. This visualization might make a good argument for adding a base class beyond p5 for Visualizers. Obviously it will not be interesting for something like the Thue Sequence (just a bunch of nodes connecting to 0 and a bunch of other nodes connecting to 1), and for permutations it will just be a collection of paths/cycles (but will let you see those in order), but for some sequences it will produce nice trees or other networks.

If the range of $a$ is a subset of the integers, say the natural numbers, it is also natural to consider the subnetwork whose nodes are the range.

As an anecdote, I had a book of activities when I was a kid, no idea what the title of it was, but one of the activities was to draw exactly this network (it's mostly two trees, with one cycle and one self-loop lurking in there) for A003132, the sequence of the sums of the squares of the decimal digits of n. I have very fond memories of spending hours making huge diagrams of these trees. I would "root for" the two trees to stay roughly equal in their number of nodes. I kept asking my parents for bigger sheets of paper. I kept being frustrated that I should redraw the whole diagram so that it would be laid out nicely, which I couldn't get right ahead of time because I didn't know where the next batch of numbers were going to connect into the trees. So then I did realize that every node is eventually going to have something connect to it, but I never really thought about trying to find the smallest number that connects to a given node, or all of the numbers up to some limit that connect to that node. I did realize that once a node had a descendant, it would keep getting more and more indefinitely.

Anyhow, it would be very personally satisfying to at some point end up with an attractive automatically-generated version of these trees...

[gwhitney]

Another natural network to plot would have vertices the range of $a(n)$ and edges from $a(n)$ to $a(n+1)$. The positions of the vertices could be specified to lie equally spaced on a line, circle, equilateral triangle, square..., or to be optimized by a network layout engine (the same goes for the networks in the main entry of this thread). Note that Edmund Harriss's celebrated visualization of the Recáman Sequence is an example of this flavor of network visualizer. In the case of placing the nodes on a closed path and connecting them by straight lines, we could also identify and color the regions of the interior of the path that the edges cut it into. (Sloane calls these "stained-glass" diagrams in the reference above.)

As usual, there is a further generalization to arbitrary formulas, $a(n)$ and $b(n)$. The vertices are either the union or the (labeled) disjoint union of the ranges of $a$ and $b$, and the (possibly directed) edges run from $a(n)$ to $b(n)$. Then we recover the original post in this thread by taking $a(n) = n$ and $b(n)$ to be the sequence of interest, and the one proposed just above in this comment by any $a(n)$ and $b(n) = a(n+1)$.

In this case, if/when this visualizer is implemented, it should be just as easy to allow the fully general $a(n)$ and $b(n)$ option, with easy presets for the two "typical" cases. Here I don't think it will make the visualizer too inaccessible for the casual visitor (just have a dropdown label with "connect the _n_th entry to" with possible values "n", "the n+1st entry", or "a value specified by formula").

[katestange]

This could totally be a visualizer: https://arxiv.org/pdf/2409.08961 -- I can imagine a few different ways you could adapt it to general sequences, but the nice thing about it is the compact circular behaviour, so I'm thinking of it for its artistic value. For how to adapt: you could just replace n with w_n in the exponential. Or you could put a w_n/q (for some q) to pick up modular behaviour (this is like taking alpha rational). Or you could let the user pick any function of w_n to put up there! Not an integer valued function of course.

[gwhitney]

Amazing how many interesting ways there are to plot dots in the unit circle! Which comment reminds me that when we do a "basic plotting" visualizer, it should have a "polar mode" (or else there should be a separate "Polar Visualizer"). And I guess that in a polar visualizer, it should be possible for the index to control the angle and the sequence value to control the radius, or vice-versa. This seems distinct to me from the Cartesian Visualizer, in which there's no pressing need in my mind to flip the X and Y axes (although it certainly wouldn't hurt, especially given that most screens are landscape...) Of course, the ability to have multiple sequences and have one control each coordinate would cover this, since you could just use Formula n for whichever coordinate you wanted to be the index. I guess you really need $n\theta$ for some small $\theta$ for the formula for the angle coordinate in the Polar case.

[katestange]

Here's a cool idea! https://observablehq.com/@tesseralis/pisano-quilts. It says "Take the Fibonacci sequence (where the next number is the sum of the previous two numbers) modulo n for some number (for example, n = 4).
This forms a cycle (for example, for n = 4, this is [0, 1, 1, 2, 3, 1, 0]). Take an n by n matrix and color every pair that is part of this sequence (e.g. (0, 1), (1, 1), (1, 2) etc.) the same color.
Then take the next smallest pair of digits (e.g. (0, 2)) and calculate the next cycle, and assign the next color in the palette to it. Continue until all cycles have been found." Lovely images!