Summary

DescriptionParabolic orbits insidse upper main chessboard box for f(z) = z^2 +0.25.svg	English: Parabolic orbits, critical orbit, attracting petals and upper main chessboard box for f(z) = z^2 +0.25. Tt is a part of dynamical plane of discete dynamical system based on the complex quadratic poynomial ${\displaystyle f_{c}(z)=z^{2}+c}$. Points of critical orbit ( including crirital point and parabolic attractor) are on the level curves like notes on the musical staff. Algorithm : "An often used and very useful technique of visualization of ramified covers (and partial cover structures that are not too messy) consists in cutting the range in domains, often simply connected, along lines joining singular values, and taking the pre-image of these pieces, which gives a new set of pieces. The way they connect together and the way they map to the range give information about the structure." Arnaud ChéritatNear Parabolic Renormalization for Unicritical Holomorphic Maps by Arnaud Chéritat[1]
Date	11 December 2015
Source	Own work
Author	Adam majewski
Other versions	DLD level curves Preimages of the circle under map f(z) = z*z+0.25 Parabolic sepals for internal angle 1 over 1 Interior of the Cauliflower Julia set

iThe source code of this SVG is valid.

 

This plot was created with Gnuplot.

Long description

It is a part of dynamical plane of discrete dynamical system based on the complex quadratic poynomial

 ${\displaystyle f_{c}(z)=z^{2}+c}$

where

  ${\displaystyle c=1/4}$

Code:

 /* Forward iteration */
 f(z):=float(rectform(z*z+c));
 
 /* backward iteration , gives only one=plus preimage */
 b(z):=float(rectform(sqrt(z-c)));
 

Algorithm

• start with 2 points:
  • critical point ${\displaystyle z_{cr}=0}$ ( here big black dot)
  • fixed point ${\displaystyle z_{f}=1/4}$ ( here big blue dot)
• then compute/draw orbits:
  • critical orbit ( images of critical point = forward iteration of crirical point) , here small black dots
  • precritical orbit ( preimages of critical point = inverse or backward iteration of critical point ), here small red dots
• boundary of chessboard box:
  • precritical part
    • join critical point and its first preimage with straight line ( segment b0)
    • compute preimages of b0 = curves joining precritical points
  • critical part: join critical point, points of critical orbit and fixed popint with segments
• draw orbits inside box ( green curves)
• attracting petals ( gray curves)
  • take 2 points: last point of critical orbit and fixed point.
  • draw circle which is passing thru above 2 points and with diameter equal to distance between such 2 points. Such circle is the smallest ( here not in general) attracting petal
  • draw preimages of such circle until such curve passes critical point ( the same number as forward iterations of critical point). Note that petal is changing shape from the circle o the ...?

 zf : GiveFixed(c) $
 critical_orbit : GiveForwardOrbit(zcr, c, 100)$
 precritical : GiveBackwardOrbit(zcr, c, 100)$

Notes

• critical orbit tends to fixed point
• precritical orbit also tends to fixed point
• all points from the interior of the main upper chesboard box tend to fixed point, some points first seems to escape from fixed point but after some iterations they chenge direction anfg go toward fixed point
• distance between points of critical orbit is geting smaller with each iteration ( exponentialy) = slow dynamic ( parabolic)
• critical point, fixed point and all point of critical orbit have imaginary part = 0 ( lay on the real axis)

Maxima CAS src code

/*

Batch file for Maxima CAS
save as a s.mac
run maxima : 
 maxima
and then : 
batch("s.mac");

*/
kill(all);
remvalue(all);

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

/* http://en.wikipedia.org/wiki/Complex_quadratic_polynomial  */

/* Forward iteration */
f(z):=float(rectform(z*z+c))$


/* backward iteration of complex quadratic polynomial 
  Principal square root */
b(z):=float(rectform(sqrt(z-c)))$



/* find fixed point alfa of function f(z,c)   */
GiveFixed(c):= float(rectform((1-sqrt(1-4*c))/2))$


/* 
converts complex number z = x*y*%i 
to the list in a draw format:  
[x,y] 
*/
d(z):=[float(realpart(z)), float(imagpart(z))]$

/* give Draw List from one point*/
dl(z):=[d(z)]$

ToPoints(myList):= points(map(d,myList))$


/* gives an orbit of z0 under fc where iMax is the length of the orbit */
 GiveForwardOrbit(z0,c, iMax):= block
(
  [i,z, orbit],
   
   z:z0,
   orbit :[z],
   i:1,
   while ( i<iMax ) 
    do
    ( 
      z:f(z),
      orbit : endcons(z, orbit),
      i:i+1
    ),
    
   return(orbit)
)$

/* gives an orbit of z0 under fc where iMax is the length of the orbit */
 GiveBackwardOrbit(z0,c, iMax):= block
(
  [i,z,  orbit],
   
   
   orbit :[],
   z : z0,
   i:1,
   while ( i<iMax ) 
    do
    ( 
      z:b(z),
      orbit : cons( z, orbit),
      /* orbit : cons(conjugate(z), orbit), */
      i:i+1
    ),
   
   return(orbit)
)$


GiveFull(z0,c, iMax):= block
([f,b],
 b:GiveBackwardOrbit(z0,c,  iMax),
 f:GiveForwardOrbit(z0,c,  iMax),
 f:append(b,f),
 
 return(f)

)$




/* 
 point of the unit circle D={w:abs(w)=1 } where w=l(t) 
 t is angle in turns 
 1 turn = 360 degree = 2*Pi radians 
 
 */
l(t):= float(rectform(%e^(%i*t*2*%pi)));

/* circle point */
cl(center, radius_, t) := float(rectform(center + radius_*l(t)));


/* here t is a real number */
GiveCircleArc(center, _radius, tmin, tmax, n):=(
  [t, dt, list],
  dt : (tmax - tmin)/n,
  
  /* add first turn */
  t : tmin,
  z: cl(center,  _radius, t),
  list : [z],
  
  
  
  /* add arc turns */
  while t < tmax do 
    ( t: t + dt,
      z: cl(center,  _radius, t),
      list : endcons(z, list)),
      list
    
)$


/* 
Line segment =  part of a line that is bounded by two end points 
input : 
- 2 endpoints : z1, z2 
- imax : number of points between endpoints
output: 
- list of complex points


*/

GiveLineSegment(z1,z2,iMax):=block
(
 [l,z, dz, t , tmin, tmax,dt,i],
 dz : z2-z1,
 dt : 1/iMax, 
 tmin: 0, 
 tmax: 1,
 z:z1,
 l:[z1],
 for t:tmin thru tmax step dt 
 
  
    do
    (
     z:z1+dz*t,
     l   :cons(z,l)
    ),
return(l)
)$



        
   

compile(all);



/* ===================== const ===================================================== */






/* 
   intager constant values 
 proportional to the : 
 * quality of the image ( number of the detailes, but also precision of curves )
 * size of the svg file ( but not the png file )
 * time of computation 
*/
jMax:1001; /* number of the circle points  */

iMax:100; /* number of the orbit points: forward and backward  */

kMax: 50; /* number of the line segment = boundary of box  */

nMax : 100; /* number of points inside green orbit */


/* parameter of the function : fc(z) = z^2 + c */
c:0.25;
zcr : 0; /* critical point */


 

/* ============================ computations =============================== */

zf : GiveFixed(c) $ /* fixed point */


/* critical orbit = forward orbit of the critical point */
critical_orbit : GiveForwardOrbit(zcr, c, iMax)$
/* precritical orbit = backward orbit of the critical point */
precritical : GiveBackwardOrbit(zcr, c, iMax)$



/* compute attracting petals :

last ( here)  attracting petal is a circle  with:
*  center on the x axis 
* radius = distance between last point of critical orbit and fixed point 
 = ( cabs(zf) + cabs(z))/2 where z is the last point of critical orbit
so in other words circle whic passes thru zl and zf
= 

Method by Scott Sutherland:[31]

choose the connected component containing the critical point
find an analytic curve which lies entirely in the Fatou set, has the right tangency property at the fixed point, and is mapped into its interior by the correct power of the map
*/

z_l : last(critical_orbit);
radius_l : (zf - z_l)/2;
center_l : z_l+ radius_l;


/* 

smallest attracting petal is a circle
under inverse iteration circle ( closed curve ): 
"Circles are split because of the branch cut along the imaginary axis"
http://functions.wolfram.com/ElementaryFunctions/Sqrt/visualizations/4/

start from 1/2 !!! not zero
this is the point where circle is splitted

*/

p0 :  GiveCircleArc( center_l, radius_l,   1/2, 3/2, jMax)$


p60 : p0$
for i: 1  thru 60  step 1 do p60 : map(b, p60)$

p70 : p60$
for i: 1  thru 10  step 1 do p70 : map(b, p70)$

p80 : p70$
for i: 1  thru 10  step 1 do p80 : map(b, p80)$
 
p81 : map (b, p80)$
p82 : map (b, p81)$
p83 : map (b, p82)$
p84 : map (b, p83)$
p85 : map (b, p84)$
p86 : map (b, p85)$
p87 : map (b, p86)$
p88 : map (b, p87)$
p89 : map (b, p88)$
p90 : map (b, p89)$


p91 : map(b, p90)$
p92 : map(b, p91)$
p93 : map(b, p92)$


p94 : map(b, p93)$

p95 : map(b, p94)$

p96 : map(b,p95)$

p97 : map(b,p96)$

p98 : map(b,p97)$
p99 : map(b,p98)$

/* 
trick : 
change first point of the list p(iMax - 1)
from origin to slightly below 
now it is different from last !!!
= split closed curve 
*/
p99[1]: -4.424164545328475E-7*%i$

p100 : map (b, p99)$
p101 : map (b, p100)$
p102 : map (b, p101)$
p103 : map (b, p102)$
p104 : map (b, p103)$
p105 : map (b, p104)$
p106 : map (b, p105)$
p107 : map (b, p106)$
p108 : map (b, p107)$
p109 : map (b, p108)$
p110 : map (b, p109)$
p111 : map (b, p110)$
p112 : map (b, p111)$
p113 : map (b, p112)$
p114 : map (b, p113)$
p115 : map (b, p114)$



/* segment between zcr and b(zcr) */
b0: GiveLineSegment(zcr,b(zcr), kMax)$

/* backward iteration of segment */
b1  : map(b,b0)$
b2  : map(b,b1)$
b3  : map(b,b2)$
b4  : map(b,b3)$
b5  : map(b,b4)$
b6  : map(b,b5)$
b7  : map(b,b6)$
b8  : map(b,b7)$
b9  : map(b,b8)$
b10 : map(b,b9)$
b11 : map(b,b10)$


b0m  : map(conjugate, b0)$
b1m  : map(conjugate,b1)$
b2m  : map(conjugate,b2)$
b3m  : map(conjugate,b3)$
b4m  : map(conjugate,b4)$
b5m  : map(conjugate,b5)$
b6m  : map(conjugate,b6)$
b7m  : map(conjugate,b7)$
b8m  : map(conjugate,b8)$
b9m  : map(conjugate,b9)$
b10m : map(conjugate,b10)$
b11m : map(conjugate,b11)$






/* green orbits inside main box */

/* choose points  */
z0 : p101[jMax -  0]$
z1 : p101[jMax -  1]   $ 
z2 : p101[jMax -  3]$ 
z3 : p101[jMax -  6]$ 
z4 : p101[jMax -  10]$ 
z5 : p101[jMax -  15]$ 
z6 : p101[jMax -  20]$ 
z7 : p101[jMax - 22]$ 
z8 : p101[jMax - 26]$ 
z9 : p101[jMax - 32]$ 
z10: p101[jMax - 40]$
z11: p101[jMax - 50]$ 

orbit0   : GiveFull(z0,  c,  nMax)$
orbit1   : GiveFull(z1,  c,  nMax)$
orbit2   : GiveFull(z2,  c,  nMax)$
orbit3   : GiveFull(z3,  c,  nMax)$
orbit4   : GiveFull(z4,  c,  nMax)$
orbit5   : GiveFull(z5,  c,  nMax)$
orbit6   : GiveFull(z9,  c,  nMax)$
orbit7   : GiveFull(z7,  c,  nMax)$
orbit8   : GiveFull(z8,  c,  nMax)$
orbit9   : GiveFull(z9,  c,  nMax)$
orbit10  : GiveFull(z10,  c,  nMax)$
orbit11  : GiveFull(z11,  c,  nMax)$









/* ----------------------------------------- draw ------------------------------- */


/* convert lists to the draw format */

p_list : [p0, p80, p81, p82, p83, p84, p85, p86, p87, p88, p89, p90, p91, p92, p93, p94, p95, p96, p97, p98, p99, p100, p101, p102, p103, p104, p105, p106, p107, p108, p109, p110, p111, p112, p113, p114]$
p_list : map(ToPoints, p_list)$
p_list : endcons(key = "Level sets of attracting time", p_list)$
p_list : endcons(ToPoints(p115), p_list)$ 

/* green = orbits */
o_list :  [orbit0, orbit1, orbit2, orbit3, orbit4, orbit5, orbit6, orbit7, orbit8, orbit9, orbit10]$
o_list : map(ToPoints, o_list)$
o_list : endcons(key = "orbits", o_list)$
o_list : endcons(ToPoints(orbit11), o_list)$ 




b0: map(d,b0)$
b1  : map(d,b1)$
b2  : map(d,b2)$
b3  : map(d,b3)$
b4  : map(d,b4)$
b5  : map(d,b5)$
b6  : map(d,b6)$
b7  : map(d,b7)$
b8  : map(d,b8)$
b9  : map(d,b9)$
b10 : map(d,b10)$
b11 : map(d,b11)$

b0m  : map(d,b0m)$
b1m  : map(d,b1m)$
b2m  : map(d,b2m)$
b3m  : map(d,b3m)$
b4m  : map(d,b4m)$
b5m  : map(d,b5m)$
b6m  : map(d,b6m)$
b7m  : map(d,b7m)$
b8m  : map(d,b8m)$
b9m  : map(d,b9m)$
b10m : map(d,b10m)$
b11m : map(d,b11m)$



critical_orbit: ToPoints( critical_orbit)$
precritical: ToPoints( precritical)$


path:"~/maxima/batch/julia/parabolic/1over1/p4/"$ /*  pwd, if empty then file is in a home dir , path should end with "/" */

/* draw it using draw package by */

 load(draw); 
/* if graphic  file is empty (= 0 bytes) then run draw2d command again */

 draw2d(
  user_preamble="set key top right; unset mouse",
  terminal  = 'svg,
  file_name = sconcat(path,"tt", string(jMax)),
  
  title= "Parabolic dynamics for f(z) = z^2 +1/4 inside upper main chessboard box",
    /* only upper box */
  dimensions = [1000, 1000],
  yrange = [-0.1,0.7],
  xrange = [-0.05,0.75],
  /* 
  full image = both 
  dimensions = [1000, 2000],
  yrange = [-0.8, 0.8],
  xrange = [-0.1, 0.75],
 */
  xlabel     = "zx ",
  ylabel     = "zy",
  point_type = filled_circle,
  points_joined =true,
  point_size    =  0.1,
  
  
  color         = gray,
  key="",
  p_list, 
  key="",
  
  
  
  
  color         = black,
  points(b0),
  points(b1),
  points(b2),
  points(b3),
  points(b4),
  points(b5),
  points(b6),
  points(b7),
  points(b8),
  points(b9),
  points(b10),
  points(b0m),
  points(b1m),
  points(b2m),
  points(b3m),
  points(b4m),
  points(b5m),
  points(b6m),
  points(b7m),
  points(b8m),
  points(b9m),
  points(b10m),
  key = "boundary of upper main chessboard box",
  points(b11),
  key="",
 
  point_size    =  0.5,
  color = green,
  o_list, 
  key="", 
  
 
  point_size    =  0.5,
  points_joined =false,
  key = "images of critical point",
  color         = black,
  critical_orbit,

 
  key = "preimages of critical point",
  color         = red,
  precritical,
  
  
  
  /*  big points */ 
  
  point_size    =  1.1,
  key= "fixed point",
  color = blue,
  points(dl(zf)),
  
  
  key= "critical point",
  color = black,
  points(dl(zcr))
    
 
 );

Postprocessing

• optimised with svgomg
• regex removed <u[^>]*BEBEBE"/> by TilmannR, Now the size is 10 times smaller !!!

Licensing

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

This file is licensed under the Creative Commons Attribution-Share Alike 4.0 International 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 give appropriate credit, provide a link to the license, and indicate if changes were made. You may do so in any reasonable manner, but not in any way that suggests the licensor endorses you or your use.
• share alike – If you remix, transform, or build upon the material, you must distribute your contributions under the same or compatible license as the original.

https://creativecommons.org/licenses/by-sa/4.0CC BY-SA 4.0 Creative Commons Attribution-Share Alike 4.0 truetrue

1. ↑ Near Parabolic Renormalization for Unicritical Holomorphic Maps by Arnaud Chéritat