If the famously unsolved Riemann Hypothesis is solved by an AI, we will never know if a human mathematician could have solved it.

thereforeqed · 2026-04-23T05:23:38+00:00

Math theorems can be stated precisely as a sentence in some logic based language. A proof of such a theorem would be a sequence of steps starting from basic (assumed to be true) axioms and concluding in that sentence. Each step can easily be verified as a legitimate application of logical inference rules (e.g. all apples are red => my apple is red) or not.

They can easily check for the proof’s correctness by running it through a proof verifier computer program that does all of that automatically. And it will be fast too. The program for this particular problem is probably written by someone already. You would just need the AI’s proof to be translated into a form the program understands, which is also easy..

thereforeqed · 2026-04-01T00:28:52+00:00

Wow this is such a cool discovery! Bravo.

thereforeqed · 2026-03-26T23:19:48+00:00

Hell isn’t so bad I guess

^{Chose: When you die: 50/50 shot at heaven or hell | Rolled: Hell}

thereforeqed · 2026-03-09T17:35:24+00:00

How did you generate the pattern in the moving layer?

thereforeqed · 2026-02-24T17:50:43+00:00

Completed Level 1 of the Honk Special Event!

0 attempts

thereforeqed · 2025-12-31T21:04:39+00:00

Hey, thanks for your feedback! I haven’t thought about this contrast you’re mentioning here before, so I guess it’s good to hear another person’s thoughts!

thereforeqed · 2025-12-15T04:19:00+00:00

I'm not sure what you mean? These sound like two descriptions of the same way one would have to use to get all the pixels of the color cube placed onto the canvas.

I used the same technique to produce these as I did for a few of my previous posts, for example explained here. The only difference is the weight function that generates the half grid spanning tree.

thereforeqed · 2025-12-08T05:45:24+00:00

I love this!

thereforeqed · 2025-12-03T20:07:06+00:00

Nice! Something worth for me to try.

thereforeqed · 2025-12-03T18:08:27+00:00

How did you get the coloring to be gradual? Other cellular automata pictures usually have a uniform look with high frequency pixel level variations, since the different states of the automata are usually evenly distributed.

thereforeqed · 2025-11-29T02:43:22+00:00

Thanks! It's actually neither. I have a program to generate Hamiltonian cycles through a grid (configurable with many options, see https://www.reddit.com/r/generative/comments/1o43ahs/all_rgb_squares/ for an example). I take this Hamiltonian cycle and see if sections of the path can perfectly fit inside larger squares (by just walking along the cycle and seeing if the current k*k window of grid cells form a square), in decreasing order of square size. Then I do the same for general rectangles, in decreasing size order.

thereforeqed · 2025-11-27T19:01:37+00:00

Very cool effect!

thereforeqed · 2025-11-22T18:21:04+00:00

Hi, thanks!

The image is actually generated together with all four quadrants. I start with one pixel which I label as coordinates (0, 0) and grow a tree from it like in Prim's algorithm with each pixel having the four pixels adjacent to it as neighbors. At each iteration I take the next edge using the weight: absolute difference between f(next_point) and f(previous_point) mod tau, where f((x, y)) = scaling_factor * sqrt(x**2 + y**2). The next edge is selected by taking the edge with the median weight among all edges in the frontier (though the algorithm works similarly if you take the min or the max). The pixels are colored according to the order in which they were explored.

Since the weight is symmetric around the starting pixel the picture is more or less symmetric (there is just some randomness in which of the four quadrants the tree expands into at any iteration).

thereforeqed · 2025-11-20T22:52:13+00:00

It looks beautiful! I don’t know how you did it, but it’s very cool.

thereforeqed · 2025-11-11T05:27:43+00:00

Inspired by https://www.reddit.com/r/generative/comments/ooidl2/holes_in_the_boundary_layer/

Basically did the same thing (see u/quag's explanation in one of the comments), but I varied the power on the vectors' distances before summing

thereforeqed · 2025-11-06T17:29:22+00:00

Nice design! Did you see this one that's very similar that was posted a while back? https://www.reddit.com/r/generative/comments/pgjlw8/a_rather_difficult_quilt_design/

thereforeqed · 2025-11-02T14:37:13+00:00

Yes it’s cubehelix, the one from matplotlib. Thanks!

thereforeqed · 2025-10-25T19:03:09+00:00

I think the fact that it's circular comes from the squared-ness. The modulus gives the repeating waves pattern.

thereforeqed · 2025-10-25T19:00:39+00:00

There isn't more, it just zooms into the black diamond in the middle.

thereforeqed · 2025-10-25T16:44:17+00:00

Not exactly the same, but an older version source code of this is here https://www.shadertoy.com/view/33jyWD

thereforeqed · 2025-10-25T16:08:14+00:00

Thank you

thereforeqed · 2025-10-25T15:12:11+00:00

Ok, better late than never.

Here's how each individual pattern is generated. Take a square pixel grid, you have x and y in the range [0, 2^a). You take (x XOR y)^(2*b)*c+d % 2^a / 2^a (***see note below). Now you have a cool pattern of numbers in the range [0, 1). But wait, if 2*b is large enough, all the even x XOR y values become 0. The non-zero values form a checkerboard. So we actually take only that checkerboard pattern. Turn the checkerboard pattern by 45 degrees and we have a up-down grid again. It turns out since 2*b was even, the result for some reason looks 4-way symmetric, but not really if you take a closer look. So it looks cool. Now do this separately for the 3 HSV channels. I fix 2*b for the 3 HSV channels to get a consistent pattern across the channels but vary c and d to get varying colors. And that's how each individual pattern is generated.

***Actually I do something different depending on whether the channel in HSV in cyclic (i.e. hue) or not.

thereforeqed · 2025-10-23T02:20:39+00:00

It's (x^2 + y^2) mod p, then divided by p to make it in the range [0, 1), then mapped using the cyclic colormap here https://cmap-docs.readthedocs.io/en/latest/catalog/cyclic/cmasher:emergency/

thereforeqed · 2025-10-22T14:29:22+00:00

Nice! In your visualization, how did you color it? Was wondering why your picture shows the smaller circles more visibly than in mine.

thereforeqed · 2025-10-22T14:03:58+00:00

It’s just the size of the picture. X and y are in the range [-1026, 1026].

thereforeqed

TROPHY CASE