File:Siegel quadratic 3,2,1000,1... ,IIM.png

Summary[edit]

Licensing[edit]

I, the copyright holder of this work, hereby publish it under the following licenses:

	This file is licensed under the Creative Commons Attribution-Share Alike 3.0 Unported license.
	You are free: to share – to copy, distribute and transmit the work to remix – to adapt the work Under the following conditions: attribution – You must attribute the work in the manner specified by the author or licensor (but not in any way that suggests that they endorse you or your use of the work). share alike – If you alter, transform, or build upon this work, you may distribute the resulting work only under the same or similar license to this one. https://creativecommons.org/licenses/by-sa/3.0 CC BY-SA 3.0 Creative Commons Attribution-Share Alike 3.0 truetrue

Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the section entitled GNU Free Documentation License.http://www.gnu.org/copyleft/fdl.htmlGFDLGNU Free Documentation Licensetruetrue

You may select the license of your choice.

This image shows main component of Julia set and its preimages under complex quadratic polynomial^[1] up to level 100007. Main component :

• contains Siegel disc ( around fixed point )
• its boundary = critical orbit
• it is a limit of iterations for every other component of filled Julia set

Algorithm[edit]

• draw critical orbit = forward orbit of critical point ( "Iterates of critical point delineate a Siegel disc"^[2])
• for each point of critical orbit draw all its preimages up to LevelMax if Hit<HitLimit

Critical orbit in this case is : dense ^[3]( correct me if I'm wrong ) in boundary of component of filled-in Julia set containing Siegel disc.^[4]

Mathemathical description[edit]

Description ^[5]

Quadratic polynomial ${\displaystyle f}$ ^[6] whose variable is a complex number

${\displaystyle f:\mathbb {C} \to \mathbb {C} }$

contains invariant Siegel disc ${\displaystyle \Delta }$ :

${\displaystyle f(\Delta )\subseteq \Delta }$

Boundary of Siegel disc ${\displaystyle B=\partial \Delta }$

• contains critical point ${\displaystyle z_{cr}}$ :
• is a Jordan curve
• is invariant under quadratic polynomial ${\displaystyle f}$ : ${\displaystyle f(\partial \Delta )=\partial \Delta }$
• is a closure of forward orbits of critical points

${\displaystyle B={\overline {f(z_{cr})}}}$

Julia is build from preimages of boundary of Siegel disc ( union of copies of B meeting only at critical point and it's preimages ):^[7]

${\displaystyle J=\bigcup _{j=0}^{\infty }f^{-j}(B)}$

Here maximal level is not infinity but finite number :

jMax = LevelMax = 100007;

rotation number[edit]

rotation number t is :^[8]

${\displaystyle t=[3,2,1000,1,...]=[0;3,2,1000,1\dots ]={\cfrac {1}{3+{\cfrac {1}{2+{\cfrac {1}{1000+{\cfrac {1}{1+\ddots }}}}}}}}}$

In Maxima CAS one can compute it :

kill(all)$
a: [0,3,2,1000,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]$
t:float(cfdisrep(a))$
l:%e^(2*%pi*%i*t)$
c:(l*(1-l/2))/2$
float(rectform(c))

So

t = .2857346725405882
c = 0.113891513213121  +0.595978335936124 i

How one can find limit of [3,2,1000,1,...] ?

Here is explanation of Bill Wood

"I don't know if Maxima knows much about the algebra of continued fractions, but it can be of some help hacking out the manipulation details of a derivation. A most useful fact is that

   [a1, a2, a3, ...] = a1 + 1/[a2, a3, ...]

provided the continued fraction converges. If we apply that three times by hand to [3, 2, 1000, 1, 1, ...] we obtain

   3 + 1/(2 + 1/(1000 + 1/[1, 1, ...]))

Now it is known that [1, 1, ...] converges to the Golden Ratio = (1+sqrt(5))/2. So now we can use Maxima as follows:

 (%i20) 3+(1/(2+(1/(1000+(1/((1+sqrt(5))/2))))));
                                    1
 (%o20)                    ---------------------- + 3
                                  1
                          ------------------ + 2
                               2
                          ----------- + 1000
                          sqrt(5) + 1
 (%i21) factor(%o13);
                              7003 sqrt(5) + 7017
 (%o21)                        -------------------
                              2001 sqrt(5) + 2005
 (%i22) %o21,numer;
 (%o22)                         3.499750279196346

You set a to [0, 3, 2, 1000, 1, 1, ...], which by our useful fact must be the reciprocal of [3, 2, 1000, 1, 1, ...], and indeed the reciprocal of 3.499750279196346 is 0.2857346725405882, which is what your float(t) evaluates to, so we seem to get consistent results.

If all of the continued fractions for the rotation numbers exhibited on the link you provided do end up repeating 1 forever then the method I used above can be used to determine their limits as ratios of linear expressions in sqrt(5)." Bill Wood

Centers of spirals[edit]

"In this example there are 7 big spirals around the Julia set. I guess this is because the rotation number is approximately [3, 2, 0, 0 , 0, ....] = 2/7.

I have checked that there is a 7-periodic point within each spiral, which will be slowly repelling. This shall be the center.

Other spirals will have preperiodic centers with period 7 and any preperiod. Maybe there are other smaller spirals at the Siegel disk belonging to higher periods, which correspond to truncating the continued fraction expansion later. " (Wolf Jung )

In program mandel^[9]

• press key b
• input rotation number .2857346725405882
• switch to dynamic plane ( F2 key)
• increase iteration number ( key n ) up to 65 000
• redraw
• draw critical orbit ( key o) ( to draw full critical orbit, "you must recompile Mandel with a larger value of plotiter in calling drawOrbit() in qmnShell" )
• find periodic point ( key x) for period 7
• make forward iteraion of this point ( key f) to see that it is a periodic point

${\displaystyle z_{0}=-0.291914002678583+0.478643728921302i}$
${\displaystyle z_{1}=-0.029994521062735+0.316532722403284i}$
${\displaystyle z_{2}=0.014598220154870+0.576989841117783i}$
${\displaystyle z_{3}=-0.218812655508313+0.612824385391645i}$
${\displaystyle z_{4}=-0.213783235906926+0.327790873680532i}$
${\displaystyle z_{5}=0.052147928299711+0.455825948583758i}$
${\displaystyle z_{6}=-0.091166375763210+0.643519093703911i}$
${\displaystyle z_{7}=z_{0}=-0.291914002678583+0.478643728921302i}$

Angles of rays landing on period 7 orbit :

9/127
18/127
36/127
72/127
144-127=17/127
34/127
68/127

Compare with[edit]

• 

  The same parameter c. Filled Julia set made with DEM/J

• 

  critical orbit, period 7 orbit, center of Siegel disc and ...

• 

  Julia set for Golden Mean made with MIIM/J ( hit limit). It contains fixed Siegel disc

C src code[edit]

/*

  c console program
  It can be compiled and run under Linux, windows, Mac 
  It needs gcc

  --------------------------------------
  draws Julia set for f(z)=z*z+c using IIM 
  ( Inverse Iteration Method )
  it is based on draw all preimages version
  modifications - hits table : if (hits[index]<HitMax)



  ------------------------------------------
  one can change :
  - LevelMax
  - HitMax
  - iSide ( width of image = iXmax = (iSide) it also changes IterationMax  = (iXmax*50)
  -  NrOfCrOrbitPoints = 2000 * iXmax;

  -----------------------------------------
  1.pgm file code is  based on the code of Claudio Rocchini
  http://en.wikipedia.org/wiki/Image:Color_complex_plot.jpg
  create 8 bit color graphic file ,  portable gray map file = pgm 
  see http://en.wikipedia.org/wiki/Portable_pixmap
  to see the file use external application ( graphic viewer)
  I think that creating graphic can't be simpler
  ---------------------------
  2. first it creates data array which is used to store color values of pixels,
  fills tha array with data and after that writes the data from array to pgm file.
  It alows free ( non sequential) acces to "pixels"
  -------------------------------------------
  Here are 4 items : 
  1. complex plane Z with points z = zx+zy*i ( dynamic plane and world coordinate )
  2. virtual 2D array indexed by iX and iYmax ( integer or screen coordinate )
  3. memory 1D array data  indexed by i =f(iX,iY)
  4. pgm file 



  Adam Majewski   fraktal.republika.pl 
 
  
  to compile : 
  gcc t.c -lm -Wall 
  to run ( Linux console) :
  ./a.out

 
  File 15.pgm saved. 

  


  NrOfPoints = 160 753 417 
  File L100005.pgm saved real	27m16.199s

  NrOfPoints = 341551869 
  File L100008.pgm saved. real	37m50.959s

  convert -version


  convert L100008.pgm -convolve "-1,-1,-1,-1,8,-1,-1,-1,-1"  -resize 2000x2000 -threshold 5% -negate L100008.png
convert h2000n20000.pgm -convolve "-1,-1,-1,-1,8,-1,-1,-1,-1"  -resize 2000x2000 -threshold 5% -negate hn.png
*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>


unsigned int NrOfPoints ;
unsigned int NrOfCrOrbitPoints ;
unsigned int HitMax = 2000; /* how many times z can be inside pixel . It must be the same typa as type of hit table !!! */ 
unsigned int LevelMax = 100007; /* nr of points = sum(2^LevelMax) */


/* iXmax/iYmax = 11/15 */
const int iSide = 10000;
int iXmax ; /* width of image in pixels = (15*iSide); */
int iYmax ;
int iLength ;
/* */
const double ZxMin = -1.5;
const double ZxMax = 1.5;
const double ZyMin = -1.5;
const double ZyMax = 1.5;
/* (ZxMax-ZxMin)/(ZyMax-ZyMin)= iXmax/iYmax  */


double PixelWidth ;
double PixelHeight ;





/* fc(z) = z*z + c */
/*  c = 0.113891513213121  +0.595978335936124 i  */
const double Cx = 0.113891513213121; /* C = Cx + Cy*i   */
const double Cy = 0.595978335936124;



/* colors */
const unsigned int MaxColorComponentValue=255; /* color component is coded from 0 to 255 ;  it is 8 bit color file */
const int iExterior = 245; /* exterior of Julia set */
const int iJulia = 0; /* border , boundary*/
const int iInterior = 230;



/* ----------------------- functions ---------------------------------------- */

/*  gives sign of number */
double sign(double d)
{
  if (d<0)
    {return -1.0;}
  else {return 1.0;};
};

unsigned int f(unsigned int iX, unsigned int iY)
/* 
   gives position of point (iX,iY) in 1D array  ; uses also global variables 
   it does not check if index is good  so memory error is possible 
*/
{return (iX + (iYmax- iY-1)*iXmax );}



int DrawPoint( double Zx, double Zy, unsigned char data[], unsigned int hits[])
{
  unsigned int iX,iY; /* indices of 2D virtual array (image) = integer coordinate */
  unsigned int index; /* index of 1D array  */ 

  /* I do not why but some points escape ; I cant find an error but it is 
     probably in code for finding preimages */
  if (Zx>ZxMax || Zx<ZxMin || Zy>ZyMax || Zy<ZyMin) return 1; /* stop */
 
  iX = (int)((Zx-ZxMin)/PixelWidth);
  iY = (int)((Zy-ZyMin)/PixelHeight);
  index = f(iX,iY);
  if (hits[index]>HitMax) return 1; /* stop if pixel is hit to often */
  
  data[index] = iJulia;  /* draw */
  hits[index] +=1;  
  NrOfPoints += 1 ; 
  
  return 0;
}



int DrawPointAndItsInverseOrbit( double Zx, double Zy, unsigned int LevelMax, unsigned char data[], unsigned int hits[])
{
  double NewZx, NewZy;
  unsigned int Level = 1; /* start from 1 to LevelMax */
  
  /* draw point */
  DrawPoint(Zx,Zy,data, hits);

  /* compute and draw all preimages up to LevelMax */
  while (Level<LevelMax)
    {
      




      /* Zn*Zn=Z(n+1)-c */
      Zx=Zx-Cx;
      Zy=Zy-Cy;
      /* sqrt of complex number algorithm from Peitgen, Jurgens, Saupe: Fractals for the classroom */
      if (Zx>0.0)
	{ NewZx=sqrt((Zx+sqrt(Zx*Zx+Zy*Zy))/2);
	  NewZy=Zy/(2*NewZx); }
      else /* ZX <= 0 */
	{
	  if (Zx<0.0)
	    { NewZy=sign(Zy)*sqrt((-Zx+sqrt(Zx*Zx+Zy*Zy))/2);
	      NewZx=Zy/(2*NewZy); }
	  else /* Zx=0 */
	    { NewZx=sqrt(fabs(Zy)/2);
	      if (NewZx>0) NewZy=Zy/(2*NewZx);
	      else NewZy=0.0; }
	};




      /* I do not why but some points escape ; I cant find an error but it is 
	 probably in code for finding preimages */
         
         
      /* first check point if not escaping and hit<hit limit  then draw it */
      if( DrawPoint(NewZx,NewZy,data, hits)) 
	{ DrawPoint(-NewZx,-NewZy,data, hits);
	  Level=LevelMax; /* else stop this subtree */
	}
      DrawPointAndItsInverseOrbit(-NewZx,-NewZy,LevelMax - Level ,data, hits);


      Zx=NewZx;
      Zy=NewZy;
      Level+=1;
     
      
              
    }

  
  return 0;

}





int DrawJulia(unsigned int pointMax, unsigned int LevelMax, unsigned char data[] , unsigned int hits[])
{
  unsigned int point; /* nr of point of critical orbit */
  double Zx,Zy;
  double Zx2,Zy2; 

  /* critical point z = 0 */
  Zx = 0.0;
  Zy = 0.0;
  DrawPointAndItsInverseOrbit(Zx,Zy,LevelMax,data, hits);
  Zx2=Zx*Zx;
  Zy2=Zy*Zy;
  /* forward orbit of critical point = critical orbit */
  for (point=2;point<=pointMax ;point++)
    {
      /* f(z) = z*z+c */
      Zy=2*Zx*Zy + Cy;
      Zx=Zx2-Zy2 + Cx;

      Zx2=Zx*Zx;
      Zy2=Zy*Zy;
      //
      printf("  %u / %u \n",point, pointMax); /* progres info */
      /* draws critical orbit */
      DrawPoint(Zx,Zy,data, hits); /* boundary of main component with Siegel Disc  */
      /* symmetric  point for each point of critical orbit */
      if (LevelMax>0) DrawPointAndItsInverseOrbit(-Zx,-Zy, LevelMax, data, hits); 
      
    }
  return 0;

}




/* --------------------------------------------------------------------------------------------------------- */

int main(){

  
 
  
  
  /* unsigned int iX,iY;  indices of 2D virtual array (image) = integer coordinate */
  iXmax = iSide; /* height of image in pixels */
  iYmax = iSide;
  iLength = (iXmax*iYmax);
  
  PixelWidth =  ((ZxMax-ZxMin)/iXmax);
  PixelHeight = ((ZyMax-ZyMin)/iYmax);

   NrOfCrOrbitPoints = 2000000 * iXmax;
 

  /* dynamic 1D arrays : data for colors ( shades of gray ) and hits */
  unsigned int index; /* index of 1D array  */
  unsigned char *data;
  unsigned int  *hits; 
  data = malloc( iLength * sizeof(unsigned char) );
  hits = malloc( iLength * sizeof(unsigned int) );
  if (data == NULL || hits==NULL )
    {
      fprintf(stderr," Could not allocate memory");
      return 1;
    }
  else printf(" memory is OK\n");
  printf(" clear the arrays \n");       
  for(index=0;index<iLength-1;++index) 
    { data[index]=iExterior;
      hits[index]=0; }



  /* ------------------ draw ----------------------- */
  printf(" Draw Julia set = %u points of critical orbit and its preimages \n",NrOfCrOrbitPoints);       
  DrawJulia(NrOfCrOrbitPoints,LevelMax, data, hits);
  printf(" NrOfPoints = %u \n", NrOfPoints);   


  /* ---------- file  -------------------------------------*/
  printf(" save  data array to the pgm file \n");
  FILE * fp;
  char name [20]; /* name of file */
  sprintf(name,"h%un2000000",HitMax); /*  */
  char *filename =strcat(name,".pgm");
  char *comment="# C= ";/* comment should start with # */
  /* save image to the pgm file  */      
  fp= fopen(filename,"wb"); /*create new file,give it a name and open it in binary mode  */
  fprintf(fp,"P5\n %s\n %u\n %u\n %u\n",comment,iXmax,iYmax,MaxColorComponentValue);  /*write header to the file*/
  fwrite(data,iLength,1,fp);  /*write image data bytes to the file in one step */
  printf("File %s saved. \n", filename);
  fclose(fp);
    

  /* --------------free memory ---------------------*/
  free(data);
  free(hits);
  
  
  
  

  return 0;
}

References[edit]

1. ↑ complex quadratic polynomial
2. ↑ Complex Dynamics by Lennart Carleson and Theodore W. Gamelin. Page 84
3. ↑ Dense set in wikipedia
4. ↑ Joachim Grispolakis, John C. Mayer and Lex G. Oversteegen Journal: Trans. Amer. Math. Soc. 351 (1999), 1171-1201
5. ↑ A. Blokh, X. Buff, A. Cheritat, L. Oversteegen The solar Julia sets of basic quadratic Cremer polynomials, Ergodic Theory and Dynamical Systems , 30 (2010), #1, 51-65,
6. ↑ wikipedia : Complex quadratic polynomial
7. ↑ Building blocks for Quadratic Julia sets by : Joachim Grispolakis, John C. Mayer and Lex G. Oversteegen Journal: Trans. Amer. Math. Soc. 351 (1999), 1171-1201
8. ↑ Some examples of quadratic polynomial Siegel disks by Davoud Cheraghi
9. ↑ Program mandel by Wolf Jung