Year-End Report
Ben Kass


My project was originally designed to focus on the properties of 
renormalization within the Mandelbrot set.  The mapping between the 
Mandelbrot set and smaller copies of itself is conformal on the inside, 
and quasi-conformal on the edge.  Nothing nice, however, can be said 
about this mapping at the cusp point, since this point is often mapped 
between sharp cusp points of cardioids and the smooth edge of a disk.  
Can anything nicer be said though if we restrict ourselves to mappings 
from cardioids to other cardioids or from the unit disk to disks within 
the Mandelbrot set?
To test this, my advisor asked me to investigate how angles formed by 
the cusp and two neighboring points was distorted by renormalization.  
It is easy enough to write programs to find some basic properties of a 
point within the Mandelbrot set.  Here are my Matlab programs for 
determining the point's Julia set's cycle size, N, the attracting (or 
parabolic) fixed point of cycle N within the filled Julia set, and the 
multiplier of the point:


function [N] = CycleSize(C);

%This function finds the cycle size of a given function x^2+C
%It returns -1 if the cycle size is above UpLim
%Or returns a 0 if the point was outside the Mandelbrot set.
%N=cycle size
%C=c-value

UpLim=20;	%Largest cycle size that will be tested for.
Tol=10^-6;		%How close 2 points must be to be considered future 
iterations of each other.

l=C;
%First we iterate many times hoping to approach a point that will 
repeat.
for a=1:1000
l=l^2+C;
end
%l is now a point that is hopefully near a fixed point
%g is future iterations of l, and we test to see if these iterations 
return near l.
%we start with g being 1 iteration further than l:
g=l^2+C;
N=1;
%Then we see if the iterations go back near that point.
while N<=UpLim & abs(g-l)>Tol
N=N+1;
g=g^2+C;
end
%The program gives up on cycles above UpLim:
if N==(UpLim+1)
N=-1;
end
%Or can tell if a point was outside the Mandelbrot set:
if or(isnan(g)==1,isinf(g)==1)
N=0;
End


function [R] = FindRoot(C,N)

%This function finds the root (fixed point) of a given function 
(x^2+C)oN=x
%R=root
%C=c-value
%N=cycle size

%If you don't know the cycle size, findroot can check it for you.
if N<=0
N=CycleSize(C);
end
%But this may lead to problems if cyclesize returns an error:
if N==0
error('This point is not in the Mandelbrot set.');
end
if N==-1
error('The cycle size was too large to compute.');
end

g=C;
l=0;
%We use Newtons method to solve for the root:
a=0;
while abs(l-g)>10^-7 & a<10000         %Change for more accuracy
a=a+1;
d=1;
l=g;
	for b=1:N
	d=d*2*l;
	l=l^2+C;
	end
g=g-(l-g)/(d-1);
end
if a==10000
disp('Something may have gone wrong with FindRoot.');
end
R=g;


function [M] = Multiplier(C,N)

%This function finds the multiplier of the root of a given function 
(x^2+C)oN=x
%M=multiplier
%C=c-value
%N=cycle size
%R=root

R=FindRoot(C,N);
M=1;
l=R;
for a=1:N
M=M*2*l;
l=l^2+C;
end


These programs are all quite simple, and I hope easy to follow.  As can 
be seen, I used Newton's method to find the fixed point.  This is 
typical of all of my programs, and in some cases leads to problems.  
Someone using my programs for research may wish to rewrite them in a 
faster language, as well as replacing Newton's method with another 
algorithm that guarantees convergence.  There are also problems with 
precision, since the polynomials that I deal with double in power over 
every increase in cycle size.  My programs begin to fall apart near 
cycle size of 10.
Anyway, moving along.  I was next confronted with the problem of finding 
the cusp of a given subset of the Mandelbrot set.  I did this again 
using Newton's method, and found that the program was easy enough to 
extend to any edge point of the given cardioid/disk.  In fact, it would 
be easy enough to find any point within the cardioid/disk with a given 
multiplier, but I never found it necessary to do this.  To find the edge 
points, however, I did need a program that would find a point within the 
cardioid/disk.  Any point will do, but it was easiest to find the center 
point.  So, here are programs used to find the center point of all 
cardioids/disks of cycle size N, and then find a point on a 
cardioid/disk with multiplier Mult, given a point on the inside of that 
cardioid/disk:


function [Center] = FindCenters(N)

%This function QUICKLY finds ALL the centers, which solve (C^2+C)oN=C.
%C=c-value
%N=cycle size
%Center=array of center values

Center=zeros(1,2^N/2);

%0 is always a root of these equations, so we pick it first.
Center(1)=0;
%Then we find other roots by dividing the polynomial by (x-Root), 
leaving a smaller
%polynomial to solve.
r=2;
while r<=(2^N/2)
%Not all starting positions lead to a root by Newton's method, so we 
may need to
%start at different points.  Ang will determind where we start.
V=0;
Ang=0;
while V==0
%g is our starting point:
g=-2*exp(i*Ang);
d=1;
a=0;
while checkcenter(g,N)==0 & a<2^N & d~=0   %Change checkcenter for 
more accuracy
		   a=a+1;
d=1;
c=g;
%This builds the full polynomial:
for b=1:(N-1)
			d=d*2*c+1;
			c=c^2+g;
end
%And this divides out the solved parts:
for b=1:(r-1)
c=c/(g-Center(b));
d=(d-c)/(g-Center(b));
end
if d~=0
g=g-c/d;
end
end
%If a root isn't found for any reason, we solve for the same 
polynomial
%starting at a new point.  Otherwise, we move on.
if or(a==2^N,d==0)
	Ang=Ang+.5;
else
	V=1;
end
	end
Center(r)=g;
%If a complex number is a root, so is it's conjugate.
if abs(imag(g))~=0
	r=r+1;
	Center(r)=conj(g);
end
r=r+1;
%This counts down the number of roots remaining to be found:
disp(2^N/2-r+1);
end


function [V] = Checkcenter (C,N);

%This function sees if C is a center of a lump of cycle N.
%C=Point to be tested.
%N=cycle size.
%V=1 if C is a center; 0 if not.

P=C;
for a=1:N
P=P^2+C;
end
if (C-P)*conj(C-P)<10^-14
V=1;
else
V=0;
end


function [Edge] = FindEdge(C,Ang)

%This function finds the edge of a lump with multiplier equal to 
e^i*Ang
%given a point in the lump.
%Edge=edge point
%C=starting point / current point
%x=the root (fixed point of cycle N)
%Ang=angle of multiplier on unit disk to find corresponding edge point 
of
%Mult=multiplier value
%Nexp=lump's cycle size

Prec=10^-3;		%How close you want the multipliers to match.
Dist=1;			%You can also look for non-edge points with multiplier:

Mult=Dist*exp(i*Ang);
Nexp=Cyclesize(C);
a=0;
%Good luck following this.  It is Newton's method from 2 equations using 
the chain
%rule to simplify the equations into one:
%(x^2+c)oN=x   		- finds the root x
%((x^2+c)oN)'=Mult	- looks for a c-value with multiplier=Mult
%I used Newton's method on the second, using c in terms of x:
while abs(Multiplier(C,Nexp)-Mult)>Prec & a<30
a=a+1;
x=findroot(C,Nexp);
dx=1;
ddx=0;
dfc=0;
dc=0;
for b=1:Nexp
ddx=2*dx^2+2*ddx*x;
dfc=2*dc*dx+2*x*dfc;
dx=dx*2*x;
dc=2*x*dc+1;
x=x^2+C;
end
f=dx-Mult;
der=dfc-ddx*(dc/(dx-1));
change=-f/der;
%The problem with Newton's method as I see it, is that it can jump 
outside of our
%lump into another region with a different cycle size - thus changing 
our
%equations and ruining the process.
%Originally, I cut back the change until it didn't leave the lump, 
but this bogged
%down the process before it was able to reach the correct point.
%Not cutting change at all occasionally led to even more bizarre 
results.
%But, after much experimentation, I found one halving of change if 
change would
%bring the C-value outside our lump, seems to give good results.  
Don't ask why.
if cyclesize(C+change)~=Nexp
change=change/2;
end
C=C+change;
end
Edge=C;
if a==30
disp('There might be a problem with FindEdge.')
end


My advisor left the country well before I had reached this point and 
would have been able to perform his study.   Therefore, I chose not to 
actually study the renormalization mappings.  This would have been 
difficult anyway, given the limitations on my programs from Newton's 
method, precision, and computational speed.  Perhaps my advisor will one 
day rewrite my programs in C and study renormalization.  Instead, I 
chose to merely show that my programs work properly by using them to 
graph some cardioids/disks from the Mandelbrot set.  This seemed like a 
logical thing to do, once I had a program that could find edge points of 
a given lump.  Here are two programs for drawing the lumps.  The first 
is needlessly complicated in order to find a nice sized display window.  
Perhaps I should have just used axis auto, but I didn't - and it doesn't 
matter:


function [Draw] = DrawAround (p)

%This function draws the lump around the point p.
%p=a point inside the lump
%points=number of edge points to draw

points=40;

X=zeros(1,points+1);
Y=zeros(1,points+1);
%Ridiculous boundaries that will necessarily be improved.
Top=-10;
Bottom=10;
Left=10;
Right=-10;

for a=1:points
disp(a);
Ang=2*pi*a/points;
Edge=FindEdge(p,Ang);
%I'm going to fit a box nicely around our lump at the end.
if imag(Edge)<Bottom
Bottom=imag(Edge);
end
if imag(Edge)>Top
Top=imag(Edge);
end
if real(Edge)>Right
Right=real(Edge);
end
if real(Edge)<Left
Left=real(Edge);
end
X(a)=real(Edge);
Y(a)=imag(Edge);   
end

%We want the lump to be complete, so we repeat the first point at the 
end.
X(points+1)=X(1);
Y(points+1)=Y(1);

%Then we add a small frame around our lump.
LR=(Right-Left)/10;
TB=(Top-Bottom)/10;

Bottom=Bottom-TB;
Top=Top+TB;
Left=Left-LR;
Right=Right+LR;

clf;
axis([Left Right Bottom Top]);
axis equal;
hold on;

plot(X,Y,'k-');



function [array] = nearby (point,testarray)

%Use this program to test what centers are near the given center point.  
You should
%probably run findcenters(N) to get an array of centers, then run this 
using that
%array as your testarray.  I didn't put much effort into this program 
because I only
%used it once.  It would be best if dist was calculated within this 
program to be twice
%the distance between point - a center point - and the edge of the 
cardioid/disk with
%center point in the direction of a given point from testarray.  
Recalculating this
%dist for each point in testarray should be easy to do with all my other 
programs.

dist=.2;	%dist to test for other centers within.  should be automated, 
but isn't.

array=zeros(1,1);
pos=1;
for a=1:length(testarray)
if abs(point-testarray(a))<dist
array(pos)=testarray(a);
drawover(testarray(a));
pos=pos+1;
end
end



function [Draw] = DrawOver (p)

%This function draws the lump around the point p.
%p=a point inside the lump
%points=number of edge points to draw

points=40;

X=zeros(1,points+1);
Y=zeros(1,points+1);

for a=1:points
disp(a);
Ang=2*pi*a/points;
Edge=FindEdge(p,Ang);
X(a)=real(Edge);
Y(a)=imag(Edge);   
end

%We want the lump to be complete, so we repeat the first point at the 
end.
X(points+1)=X(1);
Y(points+1)=Y(1);

hold on;

plot(X,Y,'k-');

axis auto;
axis equal;



Drawaround a point.  Find nearby points.  Then drawover the first 
drawing.  You get lumps that touch (if they are supposed to) without 
overlapping, just as they would in the Mandelbrot set.  The lumps all 
look like distorted disks or cardioids.  I would include some pictures, 
but don't know how to put them into Word.  Test it for yourself though.  
These programs work reasonably well as long as the cycle size of the 
lumps that you deal with isn't too large for the computer to handle.  
There are also problems with my precision constants that occasionally 
lead to problems.  Just play around with these if necessary.  That's it.