r/mathpics • u/EdPeggJr • 6h ago
A square cut into 32 similar non-right triangles, under √3 to −√3 transform
A transform of the Tom Sirgedas solution from Square Tiling.
r/mathpics • u/EdPeggJr • 6h ago
A transform of the Tom Sirgedas solution from Square Tiling.
r/mathpics • u/USedona • 1d ago
r/mathpics • u/Frangifer • 5d ago
... in this instance, an uppercase "F".
It could be said to be somewhat similar to the well-renowned Conway's automaton ... but it does something rather different ... but the updating rule is even simpler, if anything, than it is in that.
⚫
From
———————————————————————
Lattice-Gas Cellular
Automata and
Lattice Boltzmann Models
- An Introduction
by
Dieter A Wolf-Gladrow
https://epic.awi.de/id/eprint/3739/1/Wol2000c.pdf
¡¡ may download without prompting – PDF document – 2‧41㎆ !!
———————————————————————
❝
2.4.2 Fredkin’s game
Fredkin proposed a cellular automata game with simple rules which leeds
to self-replication in a trivial sense, i.e. without configurations that contain
universal Turing machines. The game is defined as follows (Gardner, 1971b).
Each cell has two possible states: alive (occupied) or dead (empty). All cells are updated simultaneously. Count the number of live cells of the four neighbors (von Neumann neighborhood of range 1; compare Fig. 2.4.6). Each cell with an even number (0, 2, 4) of live neighbors will be dead at the next time level and alive otherwise. It can be shown that any initial pattern of live cells will reproduce itself four times after 2n iterations (n depends on the initial pattern). The four replicas will be displaced 2n cells from the vanished original. Fig. 2.4.7 shows an example where n = 2.
❞
r/mathpics • u/EdPeggJr • 6d ago
A pentagon, a quadrilateral, and an octagon turn into fractals—all connected to the plastic constant, approximately 1.324718, the real solution of x³ = x + 1. Each animation runs backward to reveal the starting polygon, then forward through repeated substitutions. One particularly nice surprise: the same octagon can generate both the tent tile and the Hokkaido fractal, just by changing one transformation. Exact coordinates and construction rules appear throughout.
r/mathpics • u/imfinn005 • 6d ago
Read every digit from left to right, top to bottom, including the compressed rows of zeros: together they form one 696-digit prime. The blue cells are 9s in that number, arranged to spell ALEX MORGAN.
I made this with a fixed letter grid and a search over a few background digits. The long zero suffix means a large known factor of N−1 is a power of 10, which makes a Pocklington-style primality certificate practical. Lean checks both primality and that the digit grid reconstructs the exact number.
The public sample and its proof files are at https://setinprime.com — I’m the creator. The site is free during early access. Picture primes have a history; the site credits the Trinity Hall prime and Zachary Abel’s Prime Portraits.
Development used AI coding assistance. The artwork is rendered by explicit layout/search algorithms, not an image-generation model, and the portrait pipeline makes no AI calls.
r/mathpics • u/monsieurY • 8d ago
Hello! I've been having fun trying to compile several mathematical concepts into a single graph, mainly from reading Wikipedia pages and watching videos. I've probably made some mistakes, and I'm looking to improve, correct, and complete this graph. If you have any questions, please feel free to ask!
The sets (from bottom to top):
Qp, the p-adic numbers, which use a different absolute value (I'm not sure about the intersections of this set. I've included all the rational numbers and some of the algebraic and real numbers (computable or not)).
B, the Booleans, 0 and 1.
P, the prime numbers.
N, the natural numbers, so booleans, primes, and composite numbers. It's a semi-ring, where addition, multiplication (and integer exponentiation) can be used.
Z, the integer numbers, a ring where subtraction can also be used.
Q, the rational numbers, the first field, with division (and the signed exponent).
C', the constructible numbers, which includes the square root.
A, the algebraic numbers, which includes the nth root (and rational exponentiation).
P', the period numbers, a ring (division and exponentiation of non-natural numbers are not included) of integral of algebraic functions over an algebraic interval
EP', the exponential period numbers, still a ring that adds the integrals with the exponential function and infinite intervals
E, the elementary numbers, which are all the numbers expressible with elementary operations (therefore a field) + exponential (e is available) and logarithm (pi is available)
Rc, the computable real numbers, everything that can be calculated with algorithms, based on integrals, sequences, limits...
R, the real numbers, uncomputable, uncountable, almost only the normal random numbers
Wheel, an algebraic structure where division by zero is defined among the real numbers
Cc, the computable complex numbers, so the computable real numbers + i (this field is no longer ordered)
C, the complex numbers, almost only the random complex numbers
Re, the dual numbers, an alternative to the complex (but not a field) with e²=0 but e is not equal to 1.
Rj, the split-complex numbers, similarly with j²=1 but j is not equal to -1 and 1.
H, the quaternions, a non-commutative extension of the complex numbers.
O, the octonions, a non-associative extension of the quaternions.
S, the sedenions, a non-alternative extension of the octonions.
I'm not sure about hyperreal, superreal, surreal, and pseudoreal numbers. I've stated that surreal and pseudoreal numbers are not a set but a proper class.
Numbers:
The gray arrow indicates that the position of the number is not definitively proven; for example, we know that 2^i is transcendental (that it is not in A), but we don't know if it is a period number (P').
For non-normal numbers, I've included some constants constructed for and a small part of random numbers.
I have also added, for some numbers, their measure of irrationality and the geometric mean of the coefficients of their continued fractions.
Do you find this graph rather good or heretical? Thanks in advance!
r/mathpics
•
u/EdPeggJr
•
16d ago
A simple 2-piece pentagon substitution system builds a famous fractal related to the plastic constant, the Ammonite tile ... or the bean fractal... or the Australia fractal... of the Rauzy plastic... I wrote up the Plastic Pentagon Bean code.
r/mathpics • u/jarekduda • 20d ago
Nice new kind of puzzles on infinite board: https://zenodo.org/records/23662135
r/mathpics • u/skr_replicator • 21d ago
Rendered with my Comparser C# app (it is my own functional language with a plotter)
Coloring function: log2hsvc, which makes gradient bands from dark to light for every 1 unit of logarithmic magnitude, complex argument as hue, and lowered saturation for high values, and further darkened value for values approaching 0 (making zeroes appear dark, and large values appear whitish). The brightness banding is causing those horizontal red stripes in the zeta plot as it's oscillating around 1+0i where the gradient wraps. Most zeta plots I've seen have been using 3d height for the magnitude instead of brightness, so they don't have those bands.
So here they are, as image attachments, plotted from (-50, -50i) to (50, 50i). Pretty cool how similar the left sides of zeta and inverted gamma appear (thanks to the zeta reflection having the gamma within itself).
The images other than gamma and zeta are plotted from (-10, -10i) to (10, 10i).
Implementation of that log2hsvc:
public static (double h, double s, double v) Log2HsvC(T t) {
var s = +t; // "unary +" is overloaded as squared magnitude
var v = .5 + .5 * Static.Cycle(Math.Log(s) * .5);
return (ToHue(t), FallOffLog(s), s < 1 ? v * (.5 + .5 * s) : v);
}
public static double ToHue(T t) => Static.Cycle(T.Arg(t) / Math.Tau);
private static double FallOffLog(double s) => .1 + .899 / (1 + Math.Log(1 + Math.Sqrt(s)));
public static double Cycle(double x) => x - Math.Floor(x);My implementation of gamma:
Uses Stirling approximation with 2 kinds of corrections (corrections+shifts) that work synergistically with each other, reaching very high precision, and a reflection formula for the negative side.
private static T Gamma_Stirling_Positive(T t, int corrections = 4, int shifts = 16) => Factorial_Stirling_Positive(--t, corrections, shifts);
private static T Factorial_Stirling(T t) => 0 <= IScalar<double>.ToDouble(T.Re(t)) ? Factorial_Stirling_Positive(t) : T.Inv(Factorial_Stirling_Positive(-t) * Nsinc(t));
public static T Nsinc(T t) => Sinc(Math.PI * t);
private static T Factorial_Stirling_Positive(T t, int corrections = 4, int shifts = 16) {
// core equation with shifts:
T c = t + shifts, s = (c - .5) * T.Log(c) - c + LnTh; // LnTh = Math.Log(Math.Tau)/2
while(1 <= --shifts) // it would calculate gamma if we replaced 1 with 0, but decrementing t is simpler and faster
s -= T.LogH(T.Sqr(t + shifts)); // LogH = Ln/2
// corrections:
t = c;
for (var i = 0; i < corrections; ++i)
s += B2G[i] * (c /= T.Sqr(t)); // B2G[i] = B2[i]/(6ii+4i+2), B2[i] = B_2(i+1)
return T.Exp(s);
}My implementation of Zeta:
Uses Euler–Maclaurin expansion and zeta reflection for most of the plot, and Laurent series very close to the pole. I also tried to use a Hasse/Sondow approximation, but that didn't turn out better at any part of the plot. So I've discontinued that.
// -i * ((i)^c - (i)^(-c)) = 2sin(πc/2)
public static Complex Sin_2Q(Complex c) {
double ci = c.I * QTau, cr = c.R * QTau, cos = Math.Cos(cr), sin = Math.Sin(cr), e = Math.Exp(ci), ie = Math.Exp(-ci);
return new((e + ie) * sin, (e - ie) * cos);
}
struct ErrSum(T init) { // a structure for improving floating precision
public T Sum = init, Err;
public void Add(T x) {
T y = x - Err, t = Sum + y;
Err = t - Sum - y;
Sum = t;
}
}
public static T Zeta_Euler(T t) {
// using B2k Bernoulli numbers/factorials
int terms = 32, berns = B2F.Length << 1, k = 2;
ErrSum sum = new(unit);
for (byte n = 2; n < terms; ++n)
sum.Add(n ^ -t);
var s = terms ^ -t;
sum.Add(s * (.5 + terms / (t - 1)));
sum.Add(B2F[0] * (s *= t / terms));
for (terms *= terms; k < berns; k += 2)
sum.Add(B2F[k >> 1] * (s *= (k - 1 + t) * (k + t) / terms));
return sum.Sum;
}
// Elegant Zeta reflection: ζ(1-s)τ^s = CosI(s)Γ(s)ζ(s)
// ζ(s) = (ζ(1-s)τ^s) / (CosI(s)Γ(s))
// Zeta_Euler_Reflected(c) = Zeta_Euler(c) * R
// R = (τ ^ c) * Inv(CosI(c) * Gamma_Stirling_Negative(c)) // substitute Inv and Gamma_Stirling_Negative
// = (τ ^ c) / (CosI(c) * InvITau(Gamma_Stirling_Positive(1 - c) * SinN1(c))) // substitute InvITau
// = (τ ^ c) / (iτCosI(c) / (Gamma_Stirling_Positive(1 - c) * SinN1(c))) // simplify division
// = (τ ^ c) * Gamma_Stirling_Positive(1 - c) * SinN1(c) / (CosI(c) * i * tau) // move iτ
// = -i(τ ^ (c - 1)) * Gamma_Stirling_Positive(1 - c) * SinN1(c) / CosI(c) // substitute NISinI, and c - 1 with the difference from pole that was precomputed for the condition
// = (τ ^ c1) * Gamma_Stirling_Positive(1 - c) * NISinI(c)
public static T I_Zeta(T t) {
// relative to the pole (useful in many places in this algo, including the reflection)
var t1 = t - 1;
// squared distance from the pole
var pole = +t1;
// exactly the pole - return infinity
return pole == 0 ? T.MakeR(IScalar<double>.infty) // very near the pole - use Laurent that is excellent when this near
// hopefully 5 terms are enough for the Laurent series with the distance from to pole up to e-4
: pole < 1e-8 ? T.Inv(t1) + Static.Gamma - t * (
G1 - t * (G2 - t * (G3 - t * (G4 - t * (G5 - t * (G6 - t * (G7 - t * G8))))))) // near the pole - use general Hasse that is decent everywhere
//: pole < 1e-4 ? Zeta_Hasse(t) * T.Inv(t1) // Hasse doesn't appear to be better than either Euler or Laurent at any region
// far from pole - use Euler that is excellent when far from it (actually it seems to be excellent even very close)
: T.Re(t) >= .5 ? Zeta_Euler(t)
// negative and far from the pole - reflect Euler (using the formula derived above)
: Zeta_Euler(1 - t) * (Math.Tau ^ t1) * Gamma_Stirling_Positive(1 - t) * T.Sin_2Q(t);
}The discontinued Hasse/Sondow:
/// <summary>
/// Optimized Hasse/Sondow approximation of zeta function (without the last division by "c + 1")
/// </summary>
/// <param name="t">T input (often written as "s")</param>
/// <returns>zeta evaluated</returns>
public static T Zeta_Hasse(T t) {
// zeta(c) = (c-1)^(-1) * sum[n=0..i]: (n+1)^(-1) * sum[k=0..n]: (-1)^k * Combination(n,k) * (k + 1)^(1 - c)
// WARNING: the int[] pascal triangle overflows at 34.
// To increase maxIterations any further, you'll need to use a higher precision for "var p"
const int maxIterations = 33;
var p = new int[maxIterations + 2]; // pascal triangle rows, the first term is always zero, because it is unused
T c1 = 1 - t;
ErrSum ns = new(1.5 - (2 ^ -t));
int tri, n = p[1] = 1;
while ((tri = n) <
maxIterations
) {
ErrSum nk = new(unit); // zeroth k term is 1, precount that and loop k = n->1
while (tri > 1)
p[tri] += p[--tri];
// add the non-edge pascal triangle terms
int e, o;
if (n % 2 == 0)
(e, o) = (n, ++n);
else (o, e) = (n, ++n); // even and odd k iterators (so I don't have to (-1)^k)
++p[p[n] = 1];
// increment 2nd term in the pascal row, last term (one) in the pascal row is a new one
do nk.Add(p[e] * (e + 1 ^ c1));
// even k terms, p[e] = Combinations(n,e)
while (1 <= (e -= 2));
// decrement even k iterators down to 1
do nk.Add(-p[o] * (o + 1 ^ c1));
// odd k terms, p[o] = Combinations(n,o)
while (1 <= (o -= 2));
// decrement odd k iterators down to 1
ns.Add(nk.Sum / (n + 1));
}
return ns.Sum;
}...any more ideas what i could plot with this?
r/mathpics • u/DarkMatter-11 • 26d ago
This is from a video game about topology that I'm working on with my friend, called Trifolium: The Adventures of Gary Pretzelneck. The full version isn't out yet, but if you're interested to learn more about knots, there's a free demo on Steam.
r/mathpics • u/Shog64 • 27d ago

Hello, I hope this post can help me out because it would be kinda useful in real life, believe it or not...
I've been thinking about how to divide a pizza fairly using only straight cuts that go all the way through the center, from one edge to the opposite edge (so basically the diameter of a circle?).
For 2 people, one cut gives 2 equal halves.
For 4 people, two perpendicular cuts give 4 equal pieces.
I also thought: What if you want to divide a pizza among 3 people?
Instead of making three, in my opinion, awkward cuts from the edge to the center, you can make three full diameter cuts at 60° angles, creating 6 equal slices.
Each person simply gets 2 slices. This solution is of more pieces is always allowed in the idea.
My question: Is there a mathematical term or principle for this approach? And is there a systematic way to find the best cutting pattern for any number of people, say 1 to 10, or even more, using only "full diameter cuts" and allowing each person to receive multiple slices?
For example, what would be the smartest way to divide a pizza among 5 or 10 people under these constraints?
r/mathpics • u/Out-Live-In-Death • Oct 14 '26
Source: The graph is computed exhaustively. Each state is five digits (a, b, c, d, e), each 0–9, so there are 100,000 states. The rule shifts every value one place left and computes a new last value, a⁴ − (a³ >> 6), kept to one digit (mod 10). Here >> is a bit shift, so a³ >> 6 means a³ divided by 64, rounded down. Every state has exactly one successor, and with finitely many states every starting point must eventually repeat, so each state ends up in a cycle.
Tools: A small open-source web app I wrote (React, Vite, Canvas). It enumerates all states, finds every cycle, and draws each cycle as a ring with the states that lead into it as trees around it. The layout is crossing-free.
How to read it:
Each connected shape is one cycle plus everything that drains into it.
Colour is the length of the cycle (legend at the bottom).
Brightness fades with distance from the cycle.
For this map there are 340 cycles in total, the longest of length 10.
You can type your own formula and explore: https://exxliang193.github.io/FunctionalGraphExplorer/ Code: https://github.com/ExxLiang193/FunctionalGraphExplorer
I started this after noticing a long time ago that adding the last two digits of a number string and appending the sum always ends up repeating.
r/mathpics • u/Frangifer • Oct 11 '26
ᐜ The function SSCG(n) is the function, devised by the goodly & mickle-renownèd Harvey Friedman , that's the maximum length of a sequence of simple (ie without loops or multiple edges) subcubic (ie in which every vertex has valency @most 3) graphs
G₁ , G₂ , G₃ ...
in which Gₖ has @most n+k vertices, & for no h<k is Gₕ a minor of Gₖ . This sequence is renowned for yielding transcendentally large numbers. It's somewhat like the TREE() sequence, but (apparently) yields larger №s.
But thesedays there's a veritable menagerie of weïrd systems that have been devised, entailing all-manner of lexicographical manipulations, & wot-not (eg Fish №s, & Loader's №s) that yield №s fabulously greater still .
⚫
From
———————————————————————
Complex Projective 4-Space – Graph Minors
https://cp4space.hatsya.com/2013/01/13/graph-minors/
———————————————————————
❝
Note that there is no requirement that the graphs in question be connected. In the diagrams below, I’ll indicate the disjoint union of graphs with a plus (+) symbol, and the disjoint union of n identical graphs by preceding it with a number n. Firstly, the best lower bound I can attain for SSCG(2) is merely 3 × 2^(3 × 2^95) − 9 (i.e. less than a googolplex), which I conjecture is optimal.
It’s not difficult to show that the first few moves must be optimal. After the first move, we’re restricted to forests, and the second move further restricts us to disjoint unions of line graphs. I proceeded using a greedy algorithm, ensuring that the corresponding ordinal (replace each line graph on n vertices with the ordinal ω^(n−1)) is as large as possible. Greedy algorithms often give optimal solutions to simple problems, although others (travelling salesman, for example) resist this approach.
❞
r/mathpics • u/abstractanus • Oct 07 '26
I made this animation of the quantum harmonic oscillator, including the connection between its derivations and the shapes of its states.
The mathematical structure is a Gaussian envelope multiplied by a Hermite polynomial. Normalizability selects the allowed energy levels, while ladder operators connect neighboring states. An individual energy eigenstate changes phase without changing its probability density; superpositions introduce interference, and a coherent state gives a localized packet whose center oscillates.
The video builds those ideas visually, starting from both the power-series and operator derivations. It assumes calculus and introductory quantum mechanics; the full explanation is about 13 minutes.
r/mathpics • u/USedona • Oct 06 '26
A 3D Menger Sponge : infinite surface area, zero volume
r/mathpics • u/Mysterious-Insect858 • Oct 06 '26
r/mathpics
•
u/Rainy_Cherry2442
•
Oct 05 '26
Made them for Teachers' Day, specifically for the math and physics teachers. Hope they'll try to arrange them in the non-repeating pattern before eating them.
Took me 5.5h to make, including cutting by hand using a cutout paper shape..
I wanna sleep (i have to wake up in 1h)
r/mathpics • u/GaussCarl • Oct 03 '26
Vertices are fixed on the unit circle (the roots of unity). The orbit is the usual chaos-game rule, P ← λ(P + V), with V a randomly chosen vertex. That sequence of choices is generated once and reused for every frame. The gray dot is λ, moving once around the circle of radius 1/2 (on the second picture radius is 0.45).
You can try it yourself here https://ubavic.rs/chaos_game/
r/mathpics • u/AgreeableManner6838 • Oct 01 '26
While I’m posting these, I’m realizing I have absolutely no idea what these are actually called and “color graphs” is probably way off the mark.
So if anyone sees this and knows what these would actually be called, please let me know.
A short explanation of them is that it takes the coordinate, uses the X, Y, Distance from center, or angle from center and uses that number for the hue of the color.
(None of the ones in this post use distance or angle, they usually just complicate things more than it already is)
r/mathpics • u/protofield • Sep 30 '26
The Access Problem: Epistemological critics ask how physical human brains, operating within space and time, can interact with or gain knowledge about completely non-physical, acausal mathematical objects. Easy, geometric music, how does it work? Large, two dimensional matrices of positive whole numbers, natural numbers, are represented as images by associating each number with a coloured pixel. Audio is introduced by representing each image pixel as a sound oscillator mapping pixel colour to audio frequency, often a direct relationship to a musical scale. A region of the image is defined as a generation zone, the portion one listens to. Surrounding this is an secondary zone, the influence zone, which defines the timbrel characteristics of the pixels in the generating zone. In this video the central square is the generating zone with the outer square the influence zone. A trajectory can be defined over which the generating zone translates as a “bowing” type of motion or single zones can be “tapped” similar to a key stroke or plucked string. Perhaps the Pythagoreans envisaged something like this with their “Musica Universalis”. Its all about number, ratio and harmonies.
r/mathpics • u/Obvious_Location_423 • Sep 29 '26
r/mathpics • u/AgreeableManner6838 • Sep 24 '26
Unlike the last post, I don’t really have the math that made most of them as I was messing around, see one I like, save a pic, and move on.
Though most if not all use the same foundation, the absolute value of the slope between two points and then multiplied by an absurd amount (normally 50 to 10000 x)
Most of them also use some mixture of sin, tan, and cos of the x and y values
r/mathpics • u/Frangifer • Sep 19 '26
From
———————————————————————
'Cataclysmic' collision shaped Uranus' evolution
by
Durham University
https://phys.org/news/2018-07-cataclysmic-collision-uranus-evolution.html
———————————————————————
⚫