What is the Hausdorff dimension of the boundary of the M-set, without minis?

  • 16 Replies
  • 1096 Views

0 Members and 1 Guest are viewing this topic.

Offline Laser Blaster

  • *
  • Fractal Phenom
  • ****
  • Posts: 52
« on: March 23, 2020, 08:26:42 AM »
If you took the M-set and trimmed off all the minibrots, only leaving the main cardioid and the bulbs attached to it and the bulbs attached to those bulbs and so forth, what would the fractal dimension of the boundary be? It's certainly greater than 1. And I would say it's probably less than 2. But that's just my intuition.

Can anyone think of a method to approximate this quantity? Maybe some type of box counting program? It seems like it would be very difficult to implement, due to the need to somehow exclude minibrots.

Linkback: https://fractalforums.org/fractal-mathematics-and-new-theories/28/what-is-the-hausdorff-dimension-of-the-boundary-of-the-m-set-without-minis/3374/

Offline shapeweaver

  • *
  • Fractal Freshman
  • *
  • Posts: 8
« Reply #1 on: March 23, 2020, 12:59:18 PM »
Exactly 2 EDIT: Only if you include the decorations in the bulbs.

Why?

Look how dense it gets when you zoom very close to the main bulb. The dense areas have a local fractal dimension that approaches 2. As the "boxes" in box counting get smaller the part with the highest local fractal dimension wins and the overall fractal dimension converges to 2.

EDIT: If you only include the bulbs the dimension is around 1.2-1.4 as other forum answers found

Without minis points like 1i are in the set, but they boundary without minis won't (?) care about them. Thus we use the bulb boundary dimension I guess...
« Last Edit: March 26, 2020, 02:58:57 PM by shapeweaver »

Offline sjhalayka

  • *
  • Fractal Phenom
  • ****
  • Posts: 40
« Reply #2 on: March 23, 2020, 06:26:23 PM »
I made a Marching Squares code to find the isosurface of an input grayscale TGA file. Just render your fractal, then take it into a paint program and paint over the small regions that you're not interested in.

The code gives the dot product dimension, as well as the box-counting (Hausdorff  dimension.

https://github.com/sjhalayka/ms_curvature

Offline claude

  • *
  • 3f
  • ******
  • Posts: 1373
    • mathr.co.uk
« Reply #3 on: March 23, 2020, 06:37:26 PM »
https://math.stackexchange.com/a/1141142 my answer to "Is there a koch circle?" might provide a way to calculate it, if it is an accurate representation.  the cardioid multiplies the child bulb sizes by another factor of sin(pi p/q).

I think the similarity dimension (ignoring cardioid for the moment) is the solution s of
\[ (1/2^2)^s + 2(1/3^2)^s + 2(1/4^2)^s + 4(1/5^2)^s + 2(1/6^2)^s + 6(1/7^2)^s + 4(1/8^2)^s + 6(1/9^2)^s + \cdots + M(q)(1/q^2)^s + \cdots = 1 \]
where M(q) is the count of p coprime to q with 1 <= p < q which is less than q.

I think it can be shown s > 1 because otherwise the series would diverge (for prime q M(Q) = q - 1 so the series is larger than the sum of the reciprocals of primes if s <= 1)

Offline gerrit

  • *
  • 3f
  • ******
  • Posts: 1979
« Reply #4 on: March 23, 2020, 07:04:46 PM »
If you took the M-set and trimmed off all the minibrots, only leaving the main cardioid and the bulbs attached to it and the bulbs attached to those bulbs and so forth
Is it possible to define precisely what that means? I mean define this "trimming off" mathematically?
How would you define such a "trimmmed M-set" (tM-set)? Something like "set of c values where orbit doesn't escape, AND XXX" with XXX some property of the orbit, presumably something about period.

Offline claude

  • *
  • 3f
  • ******
  • Posts: 1373
    • mathr.co.uk
« Reply #5 on: March 23, 2020, 07:46:32 PM »
Here's a Haskell program to solve for the similarity dimension for (truncated versions) of the series I posted:
Code: [Select]
import System.IO

main = do
  hSetBuffering stdout LineBuffering
  dims

dims = sequence_
  [ putStrLn $ unwords [ show n, show (dim n) ]
  | i <- [1..], let n = 2^i
  ]

dim = solve . series

solve f = solve' 64 0 2 f

solve' n lo hi f
  | n == 0 = s
  | fs == 1 = s
  | 1 > fs = solve' n' lo s f
  | fs > 1 = solve' n' s hi f
  | otherwise = error (show (lo, s, hi, f lo, fs, f hi))
  where s = (lo + hi) / 2 ; fs = f s ; n' = n - 1

series n s = sum [ term q s | q <- [2 .. n] ]

term q s = m q * (1 / fromIntegral q ^ 2) ** s

m q = fromIntegral (length [ () | p <- [1 .. q], p `gcd` q == 1 ])

Here is the start of its output:
Code: [Select]
2 2.7755575615628914e-17
4 0.7443445704991751
8 0.9991374136410731
16 1.1031960921104798
32 1.1591418134537737
64 1.1886958407781751
128 1.2064670845654268
256 1.2174346849055913
512 1.2245084082497937
1024 1.229156651365252
2048 1.2322815021864009
4096 1.2344120081473933
8192 1.2358824503448882
16384 1.2369059447319146
32768 1.2376234452890387
65536 1.2381291299112518
131072 1.238487026122375
Maybe not enough data to see what it is converging too.
« Last Edit: March 24, 2020, 08:01:53 PM by claude, Reason: added more data points »

Offline claude

  • *
  • 3f
  • ******
  • Posts: 1373
    • mathr.co.uk
« Reply #6 on: March 23, 2020, 07:47:54 PM »
Is it possible to define precisely what that means? I mean define this "trimming off" mathematically?
Would it be the same as "start from the root cardioid, add the child bulbs, add the child bulbs of those, recursively"?  Because you can write a program to enumerate them that way.

Offline gerrit

  • *
  • 3f
  • ******
  • Posts: 1979
« Reply #7 on: March 24, 2020, 07:01:59 PM »
Would it be the same as "start from the root cardioid, add the child bulbs, add the child bulbs of those, recursively"?  Because you can write a program to enumerate them that way.
What does "add" mean precisely here? Does "add child bulb" means adding a set of well-defined inside points to the total set, or just naming the (sub) bulb.

Do you know a way to determine period of "root cardioid" (inventing terminology here), given an eventually periodic orbit?

Offline claude

  • *
  • 3f
  • ******
  • Posts: 1373
    • mathr.co.uk
« Reply #8 on: March 24, 2020, 08:00:29 PM »
What does "add" mean precisely here? Does "add child bulb" means adding a set of well-defined inside points to the total set, or just naming the (sub) bulb.

The former.  It's constructive (but explicit: from description input to points result, not implicit: from points input to boolean is-member result).

For each rational p/q in lowest terms, trace internal ray at angle p/q measured in turns. Use size estimate r = r_parent / q^2 * (if parent is cardioid then sin(pi * p/ q) else 1) to approximate the center of the child bulb's nucleus.  Use Newton's method to find nucleus of period (q * period of parent).  Use Newton's method in 2 complex variables to trace boundary of component (this is m_d_interior in my mandelbrot-numerics library, with |interior| = 1, also used for tracing internal rays with arg interior = 2 pi p / q).

Quote
Do you know a way to determine period of "root cardioid" (inventing terminology here), given an eventually periodic orbit?
I mean the unique cardioid with period 1.

Offline claude

  • *
  • 3f
  • ******
  • Posts: 1373
    • mathr.co.uk
« Reply #9 on: March 25, 2020, 05:23:37 AM »
Here is a C++ program that does the same as my Haskell program, only 100s of times faster:
Code: [Select]
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>

template<typename N, typename R> R dim(N qmax)
{
  // memoize Euler's totient function
  // https://stackoverflow.com/a/1019389
  uint64_t bytes = sizeof(N) * qmax;
  N *totient = (N *) malloc(bytes);
  if (! totient)
  {
    fprintf(stderr, "Out of memory allocating %llu bytes.\n", bytes);
    abort();
  }
  for (N q = 0; q < qmax; ++q)
  {
    totient[q] = 1;
  }
  for (N i = 2; i < qmax; ++i)
  {
    if (totient[i] == 1)
    {
      const N i1 = i - 1;
      #pragma omp parallel for if(qmax / i > 1000000)
      for (N j = i; j < qmax; j += i)
      {
        totient[j] *= i1;
        N k = j / i;
        while (k % i == 0)
        {
          totient[j] *= i;
          k /= i;
        }
      }
    }
  }
  // bisection
  const N bits = 64;
  R lo = 0;
  R hi = 2;
  R s = -1;
  for (N bit = 0; bit < bits; ++bit)
  {
    const R s_old = s;
    s = (lo + hi) * 0.5;
    if (s == s_old) break;
    const R minus2s = -2 * s;
    R f = 0;
    #pragma omp parallel for if(qmax > 1000000) reduction(+:f)
    for (N q = 2; q < qmax; ++q)
    {
      f += totient[q] * std::pow((R) q, minus2s);
    }
    if (1 > f) hi = s;
    else
    if (f > 1) lo = s;
    else
      break;
  }
  free(totient);
  return s;
}

int main(int argc, char **argv)
{
  if (! (argc > 1)) return 1;
  const uint64_t terms = std::atoll(argv[1]);
  const uint64_t qmax = terms + 2;
  double s = 0;
#define CASE(N) \
  if (uint64_t(N(qmax)) == qmax) s = dim<N, double>(N(qmax)); else
  CASE(uint8_t)
  CASE(uint16_t)
  CASE(uint32_t)
  CASE(uint64_t)
  {
    std::fprintf(stderr, "ERROR: too big\n");
    return 1;
  }
  std::printf("%.18f\n", s);
  return 0;
}

output data
Code: [Select]
#terms dimension
1 0.000000000000000028
10 1.060777931192381729
100 1.201406411704652566
1000 1.229033087191561346
10000 1.236215602473136332
100000 1.238361746259634799
1000000 1.239043488255890502
10000000 1.239265789608039459
100000000 1.239339074831453225
1000000000 1.239363342275131341
2000000000 1.239366746491320281
3000000000 1.239368275599665337
4000000000 1.239369175035730519
I think I could go to 6000000000 with 32GB RAM if I adjusted the totient array to use 32bit for the first 4G entries and 64bit for the rest..

However, I think I'm computing something different to "the dimension of the boundary of all the child bulbs".  I think it's more like "the dimension of the union of all the parabolic bond points between the child bulbs, plus Feigenbaum points after infinitely bifurcated cascades", which could be less.  The parabolic bond points are countable so their contribution to the dimension is 0.  I think there might be other points that I'm not counting? If I'm not undercounting after all, I think it would equal the dimension of the boundary of all the hyperbolic components in all minis, because minis are countable and there is no overlap (or is there?) so dim(boundary x minicenters) = dim(boundary) + dim(minicenters) = dim(boundary) + 0.

The dimension of the boundary of the Mandelbrot Set minus the interior of all the hyperbolic components (discs and cardioids) is 2, because interior is not in boundary. Also subtract all the strictly-preperiodic Misiurewicz points and you still get 2, because there are only countably many of them (so their dimension is 0).  I'm not sure if also subtracting the boundary of the hyperbolic components will still give 2, if the dimension of the boundary of the hyperbolic components is less than 2 you will get 2, otherwise you could get anything.

EDIT seems there is an altogether better way: https://math.stackexchange.com/a/3594890
« Last Edit: March 25, 2020, 09:12:29 PM by claude, Reason: link to PARI/GP solution via zeta function »

Offline sjhalayka

  • *
  • Fractal Phenom
  • ****
  • Posts: 40
« Reply #10 on: March 25, 2020, 03:55:40 PM »
I improved my code, and included a test image, at: https://github.com/sjhalayka/ms_curvature

Note: Please be patient while the code does its work... The image that I linked to has like 1700 disconnected objects.
« Last Edit: March 27, 2020, 10:58:04 PM by sjhalayka »

Offline gerrit

  • *
  • 3f
  • ******
  • Posts: 1979
« Reply #11 on: March 25, 2020, 07:30:43 PM »
On the real axis, what would be the leftmost point on the boundary of the "M-set with all minis removed"?

Offline pauldelbrot

  • *
  • 3f
  • ******
  • Posts: 1756
« Reply #12 on: March 26, 2020, 01:19:51 AM »
On the real axis, what would be the leftmost point on the boundary of the "M-set with all minis removed"?

The Feigenbaum point, presumably. Root of the spike. Point of accumulation of the sequence "elephant valley, seahorse valley, scepter valley, ...".

Offline sjhalayka

  • *
  • Fractal Phenom
  • ****
  • Posts: 40
« Reply #13 on: March 26, 2020, 03:54:37 AM »
I updated the code again: I removed all of the OpenGL/GLUT dependencies, so now the code will compile on pretty much anything.


Offline sjhalayka

  • *
  • Fractal Phenom
  • ****
  • Posts: 40
« Reply #14 on: March 28, 2020, 01:30:19 AM »
Made a small change to the code to make it an order of magnitude or so faster. The code is at: https://github.com/sjhalayka/ms_curvature