OK, I was expecting some sort of marketing BS at the start, but ... it's geniunely providing a lot more information than the "binary", black-and-whte conventional chart does.

I'm impressed.

Seems like this is one way of visualizing the solutions to many closely related equations simultaneously. I wonder what the graph looks like if instead coloring based on error, one composited all the solutions within a range of values of of the coefficients.

This sounds a lot like the programs encoded by neural networks.

It randomly gives types to cells. Certain cells move left if the left value is bigger. Other cells move right if the right value is smaller. Others randomly move back and forth.

I fail to see how it’s surprising you don’t end up with a complete sort, yet still with clusters.

That’s exactly what I’d naively expect to happen.

Really beautiful. I bet Ramanujan just “saw” and felt these.

For a general function F, finding the points (x, y) with F(x, y) = 0 has no closed-form solution. The entire field of mathematical optimization is largely dedicated to finding solutions to F(x, y) = 0, in one form or another.

When F has a special structure (say, low-order polynomial), we can actually find the exact solutions. More general structure (e.g. convexity, differentiability) doesn't give us the exact solution, but it lets use use clever numerical algorithms to find them. There are techniques we can use when F has little to no structure, known as "black box" methods, and they work particularly well when we have few variables. In the case of "fuzzy graphs", there are only two variables, so this software takes the approach of computing F(x, y) for every pixel on the screen. In general this doesn't work due to the curse of dimensionality, but it creates good visualizations in low dimensions :)

To answer your question directly, yes we can use differential geometry to speed up optimization. As an example, you've probably heard of gradient descent. Preconditioned gradient descent leverages the geometry of the surface to speed up convergence. In the language of differential geometry, if we're optimizing f(x), then x is "contravariant" but grad(f) is "covariant", so technically we can't just add grad(f) to x since they have different types. We first have to multiply grad(f) by a rank-2 tensor (the "preconditioner") that encodes the local curvature of f around x. This technique is used by the Adam optimizer, with the assumption that the preconditioner is diagonal.

People can play with graphing these in 3D and 2D here:

https://c3d.libretexts.org/CalcPlot3D/index.html

https://www.desmos.com/3d

I'm not sure I've tried that - might good idea. I've actually been playing with all kind so of visualizations - I've done most of my art as stand-alone Python scripts. Here's an open-source starting point for doing this kind of math art in Python: https://github.com/calebmadrigal/truthygraph.py. You might want to try your idea yourself :)

“For all the history of computational mathematical visualization, graphing equations has been done in binary mode...”

Intentional or not, the linked article opens with a comically untrue statement, that, because it is verifiably false, doesn't even escape as puffery. When I encounter this sort of grandstanding in framing (generally from junior engineers or fresh-from-school product managers), I spell out just how negatively such misstatements harm the point being made.

It's a turn-off for readers, and it's unnecessary.

"You may be used to seeing graphs like..." or "In grade school, we learned to graph like..."

would probably be more useful than dismissal of the history of visualization of implicit functions. Hopefully, next time, the author will be a bit less grandiose.

Noted.

Something can be deceptive without malice.

There are some truths though that are worth showing.

1. plotting in this way shows areas that are nearly solutions which is really cool.

2. Not mentioned, but this shows gradient around the solution as well, which helps understand attractor/repulsor a bit intuitively

I mean I have generated these plots before to visualize things like error or sensitivity, but this is clean and very cool. So, credit where credit is due for spreading the idea.

Yeah, the opening sentence is very easy to disprove. That's going to spark distrust among people who are "more mathy."

Otherwise ... the plot is obviously engaging, based on the discussion here. For people who haven't seen it before, it's a new way to think about it. It may well be a new "plot type" to most people relying on standard plotting software to visualize equations.

Maybe consider saying it's grounded in "more advanced" math than what others have brought to plotting software. That's still impressive, but it can be made pretty much true. You can cite cool math references about "implicit function theorem" or whatever. Stuff that your target audience really weren't going to just find on their own.

Those were popular in the 90s for image processing: e.g. https://shape.polymtl.ca/lombaert/levelset/

To be fair, yes, there are some places where non-binary graphing has been done (like error gradient graphs in AI), but as far as I know, this is the first app where you can type in a basic x/y equation and get a non-binary graph.

The first app that lets you type in an implicit curve and get a graph of its level set is a very different claim from "For all the history of computational mathematical visualization, graphing equations has been done in binary mode".

The millions of brightly-colored fractal posters adorning walls in the 80s are a very clear counter-example to your claim.

Your app is cool and the visualization is neat. The hyperbolic claims of originality really detract from that.

Dude, it's fine to be learning stuff and even writing about it.

The point about level sets is entirely that the author not only does not have the background to make claims about novelty, they have all the clues they need to figure out that they don't have the background.

It's also what scientists have done to visualize solutions of PDEs since the 1960s. Author should download Paraview and give it a twirl, to get this perspective.

First create a mesh (Sources -> Plane for 2D, or Sources -> Box if you want to do it in 3D). Set reasonably high values for Resolution on this source. Then use a filter to apply your function, either Filters -> Alphabetical -> Calculator for easy stuff, or Filters -> Alphabetical -> Python Calculator if you want complicated stuff. The "coordsX" etc. are your spatial coordinates on the mesh. Pick whatever color map you want (diverging types are good for this), change the limits on coloring, use a log scale, whatever.

If you do this in 3D on a box, you can then use a slice to scrub through the result on an arbitrarily oriented plane. You could visualize translucent isosurfaces of constant "error" and raytrace them. Or you could take the gradient of your "error" and plot as a vector field. With a bit of leg work you can add a fourth coordinate (time) and make animations. And you can combine all of these. Sky is the limit.

Is it possible to run this in a chaotic function? I would be interested to see what patterns emerge. I haven't found any code or model to generate this.

People who like these types of charts will probably also like domain coloring plots of complex functions:

https://web.archive.org/web/20120208174423/https://maa.org/p...

https://observablehq.com/@rreusser/complex-function-plotter

With a fuzzy graph, what the essay shows, we plug each point into a recipe, the equation, and see how badly it fails. Big failure → dark region (like a bitter taste). Small failure → light region (almost right). It’s just showing the raw mistake you get after plugging in x and y.

With a signed distance function, instead of looking at the recipe’s mistake, we measure how far the point is from the perfect curve—like pulling out a ruler and measuring the nearest distance to the “correct” line.

It always has units of length and behaves nicely (positive outside, negative inside, zero on the curve).

So the fuzzy graph is about “how wrong is the equation here?”

A signed distance function is “how far away from the exact solution am I?”

They’re related ideas (both start from equations written as something = 0), but they’re not the same thing.

Reasonably, I ask myself: "but isn't dark region far distance and light region close distance?"

Sitting with that:

In the fuzzy graph, we’re coloring by equation error—how badly the equation is satisfied at each point.

In a signed distance field, we color by actual geometric distance to the curve.

Those two numbers aren’t the same unless the equation is written in a very special way. If you multiply an equation by some huge factor (say, multiply everything by 1,000, or divide by something small), the shape of the solution curve doesn’t change—distance hasn’t changed—but the equation’s error suddenly becomes 1,000 times larger (or smaller). That would completely change the shading in the fuzzy graph while leaving the real distances untouched.

Signed distance is measured with a ruler (pure geometry). The fuzzy graph is measuring algebraic error (how close the formula comes to zero). Both can get lighter near the curve and darker away from it, but they’re doing it for different reasons, so they’re not interchangeable.

This is unsigned distance; it's |f(x)-g(x)|, not f(x)-g(x). The traditional line graphs are the graph implicitly defined by the equation.

Desmos has a nice renderer too:

https://www.desmos.com/3d

I need to add more details about that. But it's simply: abs(left-right)^fuzzyValue

Yep - it's just |left-right|^fuzzyLevel

I think "difference" is better, as "error" implies one side is correct and the other is an approximation. Specifically, you're plotting absolute difference z = |f(x, y)-g(x, y)| (or, worse, absolute error), not error.

Those are really cool to look at. I kept trying to click them to learn more, I wish some of them were mini blog posts to give a little bit of grounding.

Aesthetically this color map is much nicer!

Right, I just meant more that you plot more than just the equality to get some visualizations. Is also a common way to visualize game theory stuff, I thought. You want to know where the expected equilibrium is, but you also want to see, essentially, what the strength of getting there is.

I will say that in programming it's commonly used as assignment, which isn't quite the same thing as definition. golang uses it to declare variables so that's pretty close

When we say "f(x, y) = 0" in this context, we also usually have a separate definition for f(x, y) provided, where that f(x, y) is not necessarily 0 at for all x,y. And so this constraint "f(x, y) = 0" means "find pairs of x and y such that it makes f(x, y) become 0".

If "f(x, y) = 0" is actually the definition of f(x, y), then yes, it would be a pretty boring graph.

f(x, y) = 0 is true only for some combinations of x and y. It’s an equation to be solved, not a universal statement like ∀ x, y : f(x, y) = 0, nor a definition like f(x, y) ≔ 0 (or “≝”). The solutions to the equation are the points (x, y) where the graph has height 0. Which points these are depends on how f is defined.

For example, f might be defined as f(x, y) ≔ x² + y² – 1. Then the points (x, y) for which f(x, y) = 0 are those on the unit circle (those for which x² + y² = 1). The graph will have height 0 only for those points.

Reading it twice and sitting on it, I have an uneasy feeling.

It feels like it distracts more than it illuminates. ex. Quasar Equation. I don't know what it capital-M Means that at (X, Y) = 0, there's a region where there's higher differences between y and x/x^2+y^2.

But counterpoint to myself:

I'm looking at a toy example.

I'm sure there's been plenty of times I was genuinely comparing two equations and needed to understand where there'd differ.

Its just harder for me to grok when one of the equations is "y".

This is cool to look at, but isn't this just obtained by taking the absolute value of the first equation minus the second? These are very pretty visualizations—but trying to present them as some kind of "sea change" in perspective feels unhelpful.

Computers waste a ton of time being perfect when good enough would work just as well. If we get better at mapping what mostly right means, we can make more software faster by trading exactness for speed. You see this kind of thing in quantized LLMs and jpeg compression.

It's the heat map of the error surface of the equation... Fairly well understood as a concept in the land of optimization and gradient descent.

Interesting, what's being visualized there is actually a failure mode for an unidentifiable equation - the valley where the error is zero and therefore all solutions are acceptable. Introduce noise into the measurements of error and that valley being too flat causes odd behaviour

In this case, there is absolutely nothing to show on a conventional graph, as there are actual solutions to this equations.

I feel like this must be missing a "no", but also I'm bad at math, so maybe not.

There's an equal sign in the equation. That means it is true when y = x + 1. There's no filter we're applying, that's literally what the equation says. What you plot is f(x,y) = (y-x-1)/(x^2+y^2). The line plot is when that equals zero, the fuzzinss of it is when it doesnt. But notice that f(x,y)=0 is exactly equivalent to y=x+1. They're exactly the same. Thus, when you're plotting the fuzzy graph it is definitively _not_ a plot of y=x+1, it's a plot of z=(y-x-1)/(x^2+y^2) and those are not the same thing.

We'd only need to "apply a filter" to get the line graph if we started with z(x,y), but that's not what you wrote

I think the parent basically sensed that you're not a trained mathematician and is trying to throw their middle-school math textbook at you.

The simplest definition of a "graph of a function" is that it's a representation of the points satisfying some underlying equality. Your plot isn't that. A more conventional name would be a heatmap: a plot of a function that takes two parameters - x and y coordinates - and then assigns a third value (color) to each.

I don't think the distinction is all that interesting. They're both function plots.

The "graph" of a function is formally defined as exactly those points that make the equation true. https://en.wikipedia.org/wiki/Graph_of_a_function Granted, the graph is only one visualization of a function, and not the only valuable one.

Of course we also have to remember that functions are not the same as equations, and a given function, or more generally relation, can be represented by multiple different equations. For a trivial example, multiply both sides of your slashdot equation by a constant, or add x*y.

It confused me a lot - I cancelled the denominators in my head too.

But then I realised they're just plotting

y/(x^2+y^2) - (x+1)/(x^2+y^2) = c

and colouring by c (i.e. a heatmap, as others have mentioned in the thread).

That's why you get a more interesting image than you'd get with y - (x + 1) = c

Ooooh thank you!

While this perspective has merit, it is hampered by the fact that all of the examples used are polar equations, and the illustrations are therefore unnecessarily dramatic. Given that a Cartesian representation of a polar relationship is always a planar projection of the underlying conic, extremums near valid points are to expected.

It would be more useful to visually demonstrate linear relationships but of course the errors there would not make for such a punchy blog post.

Ummmm... You're just plotting a function of 2 variables (R^2 → R) as a heat map.

"Note that the Shadow Circle is invisible in the conventional graph. In fact, the conventional graph looks identical to a conventional graph of the x=0 equation (as if the denominator was not there)."

Ummm... Yeah, because the equation x / (x^2 + y^2 - 1) = 0 simplifies to x = 0. Your "fuzzy graph" is actually just a plot of the function z(x, y) = |x / (x^2 + y^2 - 1)|, where z is encoded as a color.

I was surprised to learn there is a Slashdot equation. :)

Love this!

Some years ago I made an online demo for complex domain coloring, which is related to this idea:

https://anematode.github.io/grapheme-math/demo/domain_colori...

Similar to the mapping of complex number plane with z = f(z'), that is, for a point in complex plane, new z is some function of current z for that point.

I nominate this work for a Fields Medal! (https://en.wikipedia.org/wiki/Fields_Medal)

It's seriously that good!

Also, related to the idea of visualizing old equations in new ways:

YT Video: "Putting Algebraic Curves in Perspective":

https://www.youtube.com/watch?v=XXzhqStLG-4

"Ever wonder what happens when you combine graphing algebraic curves with drawing in perspective? The result uncovers some beautiful relationships between seemingly different shapes, and all because of what happens when you

include infinity through projective geometry ."

...and the following might be of interest as well:

https://pointatinfinityblog.wordpress.com/2016/04/11/points-...

https://pointatinfinityblog.wordpress.com/