Visualisation of the field of algebraic numbers in the complex plane



Hot to plot the field of algebraic numbers in the complex plane?

enter image description here

In this picture, the color of a point indicates the degree of the polynomial of which it’s a root:

red = rational numbers

green = roots of quadratic polynomials,

blue = roots of cubic polynomials

yellow = roots of quartic polynomials, and so on

I tried first few steps:

data = Table[(-b + Sqrt[b^2 - 4 a c])/(2 a), {a, 1, 100}, {b, -100, 100}, {c, -100, 100}];

ListPlot[{Re[#], Im[#]} & /@ data, AxesOrigin -> {0, 0}, 
PlotStyle -> [Green, PointSize[.02]]]

but it doesn't work..

Thank you in advance to any one who may be able to give me some ideas


Posted 2016-05-23T17:52:48.863

Reputation: 8 518


The techniques in this question might be useful.

– J. M.'s ennui – 2016-05-23T17:57:19.667

Your link has the relevant subroutines in c++ code, but sadly the author left out a few required file: lset.c and rnd/frnd.c – M.R. – 2016-05-23T18:38:33.657


I've done similar algebraic number renderings before, see (very large image) and (moderately large image). The first image is cubics (with a special restriction on the linear coefficient) and the second is an image of the quartic roots. The typical recipe is to generate a large image array of zeros, lay down numbers at various points, blur the image, and colorize it.

– DumpsterDoofus – 2016-05-23T19:20:19.180

Do you know what determines the size of these points in that picture? – Chip Hurst – 2016-05-24T15:01:39.720



Your code works fine, but it's missing half the roots, and a Flattening of the list of numbers prior to applying Re and Im helps. Adding those in:

data = Flatten[
   Table[{(-b + Sqrt[b^2 - 4 a c])/(2 a), (-b - 
        Sqrt[b^2 - 4 a c])/(2 a)}, {a, 1, 20}, {b, -20, 20}, {c, -20, 
ListPlot[{Re[#], Im[#]} & /@ data, PlotRange -> {{-3, 3}, {-3, 3}}, 
 AspectRatio -> 1]

gets you this:

enter image description here

Which is pretty nice!

If you'd like to generate images more like the one in the Wiki article or my examples, you can do the following steps:

  1. Generate a list of complex roots of polynomials of some order N, where the vector of polynomial coefficients $\mathbf{v}=(a_0,\ldots,a_N)$ satisfies $|\mathbf{v}|\leq R$ for some cutoff radius $R$.

  2. Convert each root into a 2d coordinate by taking the real and imaginary parts.

  3. Create a sparse array, and increment the element at each root's coordinate by $\frac{1}{|\mathbf{v}|^2}$. That way, roots of simple polynomials (ie, polynomials whose coefficient vectors lie near the origin in $\mathbb{R}^{N+1}$) are "brightest", and roots of complicated polynomials (ie, polynomials whose coefficient vectors lie near the surface of the hypersphere) are dimmer. You'll need to translate, scale, and round the coordinates to be positive integers, as matrix indices must be positive integers.

  4. Blur the sparse array. The raw sparse array isn't pretty, and blurring will reveal make it obvious which points are bright, and which are dim. Using the built-in GaussianFilter is the quickest way, but it's not the best-looking. My preferred way is to FFT-convolve with a Lorentz-like distribution $\left(\frac{\gamma^2}{\gamma^2+x^2+y^2}\right)^\alpha$, where $\alpha$ determines the tail heaviness; $\alpha=1.15$ works pretty good.

  5. Colorize the resulting array $M$ and render it using Image. One easy way is to feed Image the tensor-product $M\otimes\mathbf{c}$ where $\mathbf{c}$ is some 3-element RGB vector. In Mathematica 10, TensorProduct preserves PackedArrays, whereas in older versions it doesn't, so beware of RAM consumption if you're using an older version and want large images. Incidentally, that link has some examples of algebraic number plots.

Here's an example you can get from the above:

enter image description here

IIRC the green points are $N=3$ (cubics), and the yellow ones are $N=2$ (quadratics).

Similar with just quartics (I added additional red lighting for points near the origin):

enter image description here

And a large image of monic cubics where the linear coefficient is restricted to be an 8th root of unity:

Example Code

Here's some code to do the above:

The "Root Generator" generates roots, converts them into a sparse array, and exports it to a file (steps 1-3). The "Root Visualizer" imports the files, and renders them (steps 4-5). It's got decent comments/instructions inside, but you may need to tweak the parameters to get what you want.


Posted 2016-05-23T17:52:48.863

Reputation: 11 447

Hello DD, can you maybe include an example implementation of your idea in this answer? I know that you've probably shown some of it in the other answers, but a user might benefit from seeing your description and sample code side-by-side to get the idea. – J. M.'s ennui – 2016-05-24T04:38:55.207

@J.M. Added some links to sample code (rather than pasting the code into the answer, as it's a little long). – DumpsterDoofus – 2016-05-24T05:02:07.167

Very nice. I'll test it out as soon as I'm in front of a proper machine. :) – J. M.'s ennui – 2016-05-24T05:13:59.040

@DumpsterDoofus +1 very nice. thanks :) – vito – 2016-05-25T09:45:56.747

I guess I am probably confused, but who is responsible for creating the great graphics above? I would like to ask permission to use them in papers on number theory and metamathematics. I would also love to give due credit and acknowledgment to the maths artist/s. Uh...what I mean is, what is the proper legal name I should use in published docs. – Michael Monterey – 2017-07-12T00:33:25.880