Nice new kind of puzzles on infinite board: https://zenodo.org/records/23662135

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?

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.

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?

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.

ᐜ 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.

❞

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.

A 3D Menger Sponge : infinite surface area, zero volume

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)

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/

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)

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.

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

From

———————————————————————

'Cataclysmic' collision shaped Uranus' evolution

by

Durham University

https://phys.org/news/2018-07-cataclysmic-collision-uranus-evolution.html

———————————————————————

⚫

Probably the simplest substitution periodic tiling, made by decomposing an L-like shape.

I've also made a simple app to test various tilings and export them (SVG/PNG).

... by

RISHNA CHAITANYA NVV & DIPANKAR CHATTERJEE

https://link.springer.com/article/10.1007/s12046-021-01777-z

❝

Abstract

A channel confined flow around a bluff object is significantly different from its unconfined counterpart. A confined flow is presumably more stabilized due to the presence of the confinement. This causes a delay in the onset of flow separation and vortex shedding in comparison to the unconfined flow. While the above facts have been reported for the confined flow around a circular object in a channel, the same for a square object is infrequent. The present study focuses on the steady flow past a stationary square cylinder placed in a channel at low Reynolds numbers. The behavior of the flow is observed through numerical simulation for various channel confinements (, blockage ratio). The steady state laminar two-dimensional incompressible flow equations are solved using a finite volume based technique. An effort is made to find the separation critical Reynolds number at all blockages. It is observed that the separation critical Reynolds number increases with an increase in the blockage ratio. Unsteady flow characteristics at various blockages are also studied at Re = 100. In the unsteady regime, the frequency of vortex shedding increases with an increase in the blockage.

a(n) is the number of integer tuples (x_1, x_2, ..., x_(k+1)) where 0 <= x_i <= b-1, such that |x_i - x_(i+1)| = d_i for all i, where (d_1, d_2, ..., d_k) are digits of n in base b.

Animation varies base b from 2 to 50 (grid size is b^2) and the mapping is (x,y) gets a(x xor y) mod 4 which is visualised by color.

When I woke up today, the spoonerism was already in my mind, so I made this.

https://imgur.com/a/mqVMuyN

the goal is to make a spiral spiraling around a spiral thats spiraling around a spiral thats spiraling around a spiral until my computer crashes.

sometimes a loop of loops loop around the looping loops loop looped too

To be clear, I made the payment of $1,041.38 in May and the final installment payment of $890.50 will be paid on Friday. I've called three times and each time I get a little different color smoke blow up my exit hole.

Hi

If you are remotely interested in deep diving how differently quantum computers work compared to our transistor-based and also the algebra behind in a fully interactive way that teach computer science from scratch, oh boy this is for you. I am the Dev behind Quantum Odyssey (AMA! I love taking qs) - worked on it for about 10 years (3+ during PhD, the visual method I developed ended up being my thesis, it is a complete Hilbert space visualizer), the goal was to make a super immersive space for anyone to learn quantum computing through zachlike (open-ended) logic puzzles and compete on leaderboards and lots of community made content on finding the most optimal quantum algorithms. The game has a unique set of visuals capable to represent any sort of quantum dynamics for any number of qubits and this is pretty much what makes it now possible for anybody 12yo+ to actually learn quantum logic without having to worry at all about the mathematics behind.

This is a game super different than what you'd normally expect in a programming/ logic puzzle game, so try it with an open mind.

Stuff you'll play & learn a ton about

• Boolean Logic – bits, operators (NAND, OR, XOR, AND…), and classical arithmetic (adders). Learn how these can combine to build anything classical. You will learn to port these to a quantum computer.
• Quantum Logic – qubits, the math behind them (linear algebra, SU(2), complex numbers), all Turing-complete gates (beyond Clifford set), and make tensors to evolve systems. Freely combine or create your own gates to build anything you can imagine using polar or complex numbers.
• Quantum Phenomena – storing and retrieving information in the X, Y, Z bases; superposition (pure and mixed states), interference, entanglement, the no-cloning rule, reversibility, and how the measurement basis changes what you see.
• Core Quantum Tricks – phase kickback, amplitude amplification, storing information in phase and retrieving it through interference, build custom gates and tensors, and define any entanglement scenario. (Control logic is handled separately from other gates.)
• Famous Quantum Algorithms – explore Deutsch–Jozsa, Grover’s search, quantum Fourier transforms, Bernstein–Vazirani, and more.
• Build & See Quantum Algorithms in Action – instead of just writing/ reading equations, make & watch algorithms unfold step by step so they become clear, visual, and unforgettable. Quantum Odyssey is built to grow into a full universal quantum computing learning platform. If a universal quantum computer can do it, we aim to bring it into the game, so your quantum journey never ends.

Nice to watch:

Khan academy style tutorials in qm/qc: https://www.youtube.com/@MackAttackx

Physics teacher stream with 400hs in https://www.twitch.tv/beardhero