Replies: 40 comments 33 replies
-
|
"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. |
Beta Was this translation helpful? Give feedback.
-
|
A variation suggested by Tom Edgar: draw a regular i-gon at a radius determined (in some way) by a_i. |
Beta Was this translation helpful? Give feedback.
-
|
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. |
Beta Was this translation helpful? Give feedback.
-
Beta Was this translation helpful? Give feedback.
-
|
We should be able to reproduce this as a featured visualizer with FormulaGrid, I think. |
Beta Was this translation helpful? Give feedback.
-
|
A variation on the grid visualizer that uses the fibonacci-voronoi/sunflower-seed cells, e.g. https://www.neatoshop.com/product/Fibonacci-modulus. |
Beta Was this translation helpful? Give feedback.
-
|
There was also discussion of Voronoi-based visualizer on the illustrating-math discord, e.g. https://discord.com/channels/862052650208329739/862059972904091678/1429985335651336373 |
Beta Was this translation helpful? Give feedback.
-
|
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.) |
Beta Was this translation helpful? Give feedback.
-
|
Given a series 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. |
Beta Was this translation helpful? Give feedback.
-
|
Nice. I assume you mean the function from |
Beta Was this translation helpful? Give feedback.
-
|
Plot the Borel sum of a series. |
Beta Was this translation helpful? Give feedback.
-
|
You mean this: https://en.wikipedia.org/wiki/Borel_summation ? Same kind of picture as for the direct power series? |
Beta Was this translation helpful? Give feedback.
-
|
Yup, that's the one. |
Beta Was this translation helpful? Give feedback.
-
|
Might we possibly also be interested in visualizing just the Borel transform of the sequence, i.e. the function |
Beta Was this translation helpful? Give feedback.
-
|
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. |
Beta Was this translation helpful? Give feedback.
-
|
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 |
Beta Was this translation helpful? Give feedback.
-
|
Here's something that visualizes hitomezashi patterns, it's a type of visualizer of sequences: https://github.com/dwildstr/hitomezashi-explorer |
Beta Was this translation helpful? Give feedback.
-
|
We can do this with one sequence down each axis, or the same sequence down each axis, and use parity of the sequence to determine the "stitch pattern". The basic hitomezashi method uses just a binary sequence (hence the parity) Is there any generalization of this to other moduli? |
Beta Was this translation helpful? Give feedback.
-
|
https://arxiv.org/abs/2208.14428 may be relevant here |
Beta Was this translation helpful? Give feedback.
-
|
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. |
Beta Was this translation helpful? Give feedback.
-
|
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. |
Beta Was this translation helpful? Give feedback.
-
|
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. |
Beta Was this translation helpful? Give feedback.
-
|
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... |
Beta Was this translation helpful? Give feedback.
-
|
Yup, that's right. I think a gradual fading on cells after they are turned on is another way to represent time nicely. |
Beta Was this translation helpful? Give feedback.
-
|
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 |
Beta Was this translation helpful? Give feedback.
-
|
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. |
Beta Was this translation helpful? Give feedback.
-
|
Variation on chaos visualizer, was #248: https://twitter.com/matthen2/status/1268808515574886407On 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... |
Beta Was this translation helpful? Give feedback.
-
|
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. |
Beta Was this translation helpful? Give feedback.
-
|
One key idea here is that we do have all of the ingredients for interactive visualizers: a visualizer can call stop in its draw method and continue in its mouse/key methods. |
Beta Was this translation helpful? Give feedback.
-
|
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 |
Beta Was this translation helpful? Give feedback.
-
|
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... |
Beta Was this translation helpful? Give feedback.
-
|
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.... |
Beta Was this translation helpful? Give feedback.
-
|
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 |
Beta Was this translation helpful? Give feedback.
-
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. |
Beta Was this translation helpful? Give feedback.
-
|
I think the Formula Grid visualizer will do all of these things at this point; perhaps we should try them as featured specimens... |
Beta Was this translation helpful? Give feedback.
-
|
Could do something like this with each ray angle being determined by the sequence: https://penrose.cs.cmu.edu/try/?examples=interactive%2Fellipse-rays |
Beta Was this translation helpful? Give feedback.
-
|
Variation on chaos game: https://penrose.cs.cmu.edu/try/?examples=fractals%2Fchaos-game%2Fsierpinski-triangle |
Beta Was this translation helpful? Give feedback.
-
|
Idea: Search for some terms on OEIS and you get a bunch of sequences that return. Could you visualize the collection? Graph them all somehow -- I'm imagining something like how you could graph all the polynomials that go through certain points or something. Maybe this would portray if most sequences have the same next value, for example. |
Beta Was this translation helpful? Give feedback.
-
|
SUPER vague idea: it's fun to visualize algorithms in action. Are there cool algorithms on sequences that we could animate? |
Beta Was this translation helpful? Give feedback.
-
|
the first idea that comes to mind here is to visualize different sort algorithms (like bubble sort) on the entries of a sequence. Monotone sequences would have boring visualizations, but up-and-down sequences like Recaman or Collatz-type sequences might produce very nice pictures/animations. Not sure if you just start with a finite subsequence, or if you progressively add one (or k) new terms at the end of what you have partially sorted so far, on each turn. |
Beta Was this translation helpful? Give feedback.
-
|
Free association from Chris Hanusa at IHP Semester:
|
Beta Was this translation helpful? Give feedback.
-
|
Virtually any process (that can be visualized) that is described in the literature as being controlled by random numbers can be adapted into a Numberscope visualization, by using the sequence as the source of the numbers controlling the process. For example, consider some percolation models. You could take just about any one, like say the Eden model, and then just use the sequence (perhaps appropriately modded) to control where the next cell is added. (Note there are variations on the Eden model depending on what collection of cells are taken and how they are connected.) |
Beta Was this translation helpful? Give feedback.
-
|
Inspirational image for a 3d turtle visualizer: https://www.brown.edu/news/2025-12-09/cancer-discovery |
Beta Was this translation helpful? Give feedback.
-
|
Cross-sequence visualizers: it could be nice to have a visualizer in which each dot or bar corresponded to a different OEIS sequence, and what was displayed was some characteristic of the sequence, like how fast it grows, whether it is signed, how many entries are known, etc. etc. Ideally then you click on a point and go to some visualization of that sequence. |
Beta Was this translation helpful? Give feedback.
-
|
p-adic visualizer: use the discs-and-subdiscs standard picture of the p-adics on the screen. Colour each ball in some way with reference to the interaction of the sequence with that ball. For example:
|
Beta Was this translation helpful? Give feedback.
-
|
Tree visualizer: creates a tree (maybe radiating out in a hyperbolic way) of whatever degree, and then colour the nodes (or the hyperbolic regions?) according to the sequence in some way. For example, this could be a version of the p-adic visualizer in the comment above. Or you could use it to visualize any trees in OEIS. |
Beta Was this translation helpful? Give feedback.
-
|
Nice idea and yes I think there are quite a few "tree visualizer" ideas on here now, if you browse throughout. Anyone starting work on one of these ideas should go through them and see which are similar/more different and map out a chunk of such functionality that's reasonably unified. |
Beta Was this translation helpful? Give feedback.
-
|
This paper discusses some very interesting ways to make graphs out of sequences. Amazing pictures! https://arxiv.org/abs/2012.04625 |
Beta Was this translation helpful? Give feedback.
-
|
Yes, another reason to get network layout into Numberscope! Also, one plausible way to lift the restriction to injective sequences (besides removing duplicates as the authors do) is to have the vertices be the pairs (a_n, n) and sort them lexicographically. In other words, we just decree that all the constant subsequences are "increasing". |
Beta Was this translation helpful? Give feedback.
-
|
Entered during Steve Trettel's shading primer: we could/maybe should have a shader visualizer (or visualizer base class) that lets you enter shader code (either live in the brower, or in the source code) and just directly displays the resulting shader. |
Beta Was this translation helpful? Give feedback.
-
|
There are algorithms for visualizing high dimensional data, like Principal Component Analysis or "t-SNE". We could run this type of thing on all subsequences of length n from our sequence. Or, of course, other functions on the sequence with high dimensional output, maybe, for example, factorizations (the vector of exponents on small primes, say). |
Beta Was this translation helpful? Give feedback.
-
|
In this paper, the authors take pairs of numbers (A,B) to the line Ax+By=1 in the plane, and note that the line arrangement (in particular, its collection of polygonal regions) has special properties when the set of pairs (A,B) has special properties (e.g., when the pairs are a rectangle of lattice points, or when their coordinates are given by Fibonacci numbers) and they make an interesting observation about the number of polygonal regions that appear in the line arrangement in certain cases. Perhaps we could consider how to go from a sequence to a line arrangement (we could chop the sequence up into pairs and use this correspondence, but there may be other worthwhile ways) and display the line arrangement. |
Beta Was this translation helpful? Give feedback.
-
|
Every number can be drawn as a rooted forest -- this goes by the name of Matula arborification: |
Beta Was this translation helpful? Give feedback.
-
|
Nice references :) How to turn a forest for each integer into a visualization of a sequence is a bit less clear, but definitely food for thought. |
Beta Was this translation helpful? Give feedback.
Uh oh!
There was an error while loading. Please reload this page.
-
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.
Beta Was this translation helpful? Give feedback.
All reactions