Summary

DescriptionPreimages of the circle under map f(z) = z*z+0.25.svg	English: Preimages of the green circle under map ${\displaystyle f(z)=z^{2}+0.25}$. Preimages of the green circle from the interior gives level curves of the attracting time ( boundaries of the level sets). Green circle here is an attracting petal of the Leau–Fatou flower. Fixed point is on the circle and on the boundary of the Fatou set. Standard view is not readible so click on the image to see animation !! Reload ( refresh ) to see it again.
Date	16 March 2018
Source	Own work
Author	Adam majewski
Other versions	Parabolic orbits insidse upper main chessboard box for f(z) = z^2 +0.25 Parabolic sepals for internal angle 1 over 1 Interior of the Cauliflower Julia set Backward iteration of complex quadratic polynomial with proper chose of the preimage Preimages of circle with radius = ER give level sets of escape time ( or attraction time to infinity )
SVG development InfoField	The SVG code is valid.   This plot was created with Gnuplot.

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

Algorithm

• start with the function : complex quadratic polynomial
• compute fixed point
• compute critical orbit ( orbit of the critical point ) which tend to the fixed point
• take 2 points

• • fixed point
• draw a circle
  • thru 2 points:
    • fixed point
    • last point of the critical orbit
  • with center in the midpoint of above points
• draw preimages of critical point under our function
• compute/draw preimaes of the circle under our function

Note :

• there are 2 preimages

Green circle

• Radius of the circle is equal to half of the distance between parabolic fixed point ( big blue dot) and last point of critical orbit ( black dots )
• Center of the green circle is a midpoint between above 2 points

Gray curves

• gray curves are preimages of green circle
• preimages
• go to the left ( from fixed point to the critical point = along critical orbit in the reverse direction) until meet the critical point
• then closed curve is splitted to the curve which join red points ( preimage of critical point and it's symmetric point)
• all preimages tend to the fixed point from the right

Maxima CAS src code

/*

Batch file for Maxima CAS
save as a o.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))$



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)]$



/* 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 :[d(z)],
   i:1,
   while ( i<iMax ) 
    do
    ( 
      z:f(z),
      orbit : endcons(d(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(d( z), orbit),
      orbit : cons(d(conjugate(z)), orbit),
      i:i+1
    ),
   
   return(orbit)
)$






/* 
 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):=block(
  [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
    
)$


/* slimming the list 

only between iMin and  iMax
iMin : angle =1/4
iMax : angle = 3/4
*/  


SlimList(MyList, n):=block(
	[NewList, iMax, iMin, l], 
	NewList:[first(MyList)],
	l : length(MyList),
	iMin: l*0.2,
	iMax: l*0.8,
	for i:1 thru l step 1 do 
		(if (i>iMin and i<iMax) 
			then (if (mod(i,n)=0) then  NewList:endcons(MyList[i],NewList))
			else NewList:endcons(MyList[i],NewList)
		),
	NewList : endcons(last(MyList), NewList),
	NewList

)$      


   

compile(all);


jMax:1000;

/* variables */

c:0.25;
zcr : 0; 


 

/* computations */

zf : GiveFixed(c) $







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



/* 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)[1];
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 
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)$




/* make lists smaller */

p0: SlimList(p0, 500)$
p80: SlimList(p80,500)$
p81: SlimList(p81,500)$
p82: SlimList(p82,500)$
p83: SlimList(p83,500)$
p84: SlimList(p84,500)$
p85: SlimList(p85,500)$
p86: SlimList(p86,500)$
p87: SlimList(p87,500)$
p88: SlimList(p88,500)$
p89: SlimList(p89,500)$
p90: SlimList(p90,500)$
p91: SlimList(p91,500)$
p92: SlimList(p92,500)$
p93: SlimList(p93,500)$
p94: SlimList(p94,500)$
p95: SlimList(p95,500)$
p96: SlimList(p96,500)$
p97: SlimList(p97,500)$
p98: SlimList(p98,100)$
p99: SlimList(p99,100)$
p100: SlimList(p100,100)$
p101: SlimList(p101,100)$
p102: SlimList(p102,500)$
p103: SlimList(p103,500)$
p104: SlimList(p104,500)$
p105: SlimList(p105,500)$
p106: SlimList(p106,500)$
p107: SlimList(p107,500)$
p108: SlimList(p108,500)$
p109: SlimList(p109,500)$
p110: SlimList(p110,500)$
p111: SlimList(p111,500)$
p112: SlimList(p112,500)$
p113: SlimList(p113,500)$
p114: SlimList(p114,500)$
p115: SlimList(p115,500)$





/* to draw format */



p0 : map(d, p0)$
/*
p60: map (d, p60)$
p70: map (d, p70)$
*/
p80: map (d, p80)$
p81: map (d, p81)$
p82: map (d, p82)$
p83: map (d, p83)$
p84: map (d, p84)$
p85: map (d, p85)$
p86: map (d, p86)$
p87: map (d, p87)$
p88: map (d, p88)$
p89: map (d, p89)$
p90: map (d, p90)$
p91 : map(d, p91)$
p92 : map(d, p92)$
p93 : map(d, p93)$
p94 : map(d, p94)$
p95 : map(d, p95)$
p96 : map(d, p96)$
p97 : map(d, p97)$
p98 : map(d, p98)$
p99 : map(d, p99)$
p100 : map(d, p100)$
p101 : map(d, p101)$
p102 : map(d, p102)$
p103 : map(d, p103)$
p104 : map(d, p104)$
p105 : map(d, p105)$
p106 : map(d, p106)$
p107 : map(d, p107)$
p108 : map(d, p108)$
p109 : map(d, p109)$
p110 : map(d, p110)$
p111 : map(d, p111)$
p112 : map(d, p112)$
p113 : map(d, p113)$
p114 : map(d, p114)$
p115 : map(d, p115)$




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

path:"~/maxima/batch/julia/parabolic/1over1/circle_preimages/c4/small/s2/"$ /*  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,"s", string(jMax)),
  
  title= "Preimages of the circle  for f(z) = z^2 +1/4",
  dimensions = [1000, 2000],
 
  yrange = [-0.75, 0.75],
  xrange = [0, 0.75],
 
    xlabel     = "zx ",
  ylabel     = "zy",
  point_type = filled_circle,
  
  
  
  
  
  
  points_joined =true,
  point_size    =  0.1,

  color         = green,
 
  
  key="green circle",
  points(p0),
  
  color         = gray,
  key = "",
   
  /*
  here not drawn because of  dense image 
  points(p60),
  points(p70),
  */
  
  /* points(p80),
 points(p81),
  points(p82),
  points(p83),
  points(p84),
  points(p85),*/
  points(p86),
  points(p87),
  points(p88),
  points(p89),
  points(p90),
  points(p91),
  points(p92),
  points(p93),
  points(p94),
  points(p95),
 
  points(p96),
  points(p97),
  points(p98),
  points(p99),
  points(p100), 
  points(p101),
  points(p102), 
  points(p103), 
  points(p104),
  points(p105), 
  points(p106), 
  points(p107),
  points(p108), 
  
  points(p109), 
  points(p110),
  points(p111),
  points(p112), 
  
  points(p113), 
  points(p114),
  key = "preimages of the green circle",
  points(p115),
  
  
 
  point_size    =  0.5,
  points_joined =false,
  key = "images of critical point",
  color         = black,
  points(critical_orbit),

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

Postprocessing

The size of svg image is to big.

"I simply opened the file in a text editor to see what's wrong with it and edited it down to the current version with regex substitutions. Of course regexes can be a bit tricky and the older version of the file is so slow to render that I didn't check for deviations as thoroughly as I should have." TilmannR

"The text editor I used was Notepad++[1], but that's not particularly relevant.

I don't remember each individual pattern I used, but the main culprit definitely were lines like <use xlink:href='#gpPt6' transform='translate(600.3,998.2) scale(0.45)' color='rgb(190, 190, 190)'/>. There are 12141 of those, each about 100 characters long, so approximately 1.2 MB in total. A short regex for that is e.g. <use[^>]*190, 190, 190\)'/>, but the real solution to superfluous elements is to not generate them at all. Apparently it's possible to avoid generating points by setting their point_type to -1. If I was more familiar with Maxima, I'd fix the script, but I'm not, so I won't.: TilmannR (talk) 21:03, 19 May 2018 (UTC)