"大多数用于计算 Julia 集的程序在底层动力学为双曲线时工作良好，但在抛物线情况下会遇到指数级减速。" (Mark Braverman)^[1]

换句话说，这意味着使用标准/朴素算法可能需要几天时间才能制作出抛物线 Julia 集的优质图像。

这里有两个问题

缓慢（= 懒惰）的局部动力学（在抛物线不动点附近）
某些部分非常薄（使用标准平面扫描很难找到）

平面

动态平面

动态平面 = 复 z 平面 $\mathbb {C} =J_{f}\cup F_{f}$

Julia 集 $J_{f}\subset \mathbb {C}$ 是一个公共边界： $J_{f}\,=\partial A_{f}(p)=\partial A_{f}(\infty )$
Fatou 集 $F_{f}\subset \mathbb {C}$ $F_{f}\subset \mathbb {C}$
- Julia 集的外部 = 无穷大的吸引盆地： $A_{f}(\infty )\ {\overset {\underset {\mathrm {def} }{}}{=}}\ \{z\in \mathbb {C} :f^{(k)}(z)\to \infty \ as\ k\to \infty \}.$
- Julia 集的内部 = 有限的抛物线不动点 p 的吸引盆地： $A_{f}(p)\ {\overset {\underset {\mathrm {def} }{}}{=}}\ \{z\in \mathbb {C} :f^{(k)}(z)\to p\ as\ k\to \infty \}.$ $A_{f}(p)\ {\overset {\underset {\mathrm {def} }{}}{=}}\ \{z\in \mathbb {C} :f^{(k)}(z)\to p\ as\ k\to \infty \}.$
  - 直接盆地 = 包含抛物线不动点 p 在其边界上的分量的总和；p 的直接抛物线盆地是抛物线盆地的周期性连通分量的并集。
    - 吸引 Lea-Fatou 花 = n 个吸引花瓣的总和 = 2*n 个吸引萼片的总和
      - 花瓣 = 花的一部分。每个花瓣包含两个萼片的一部分。
      - 萼片 (设 1 是第一象限中的一条不变曲线，L 1 是 1 ∪ {0} 包围的区域，称为萼片。)^[2]

$\mathbb {C} \supset F(f)\supset A_{f}(p)$

另请参阅

填充的Julia集^[3] $K_{f}$

关键词

抛物线棋盘或棋盘
抛物线内爆
Fatou 坐标
夏威夷耳环
- 维基百科中 = “由一系列圆形组成，所有圆形在同一处相切，且半径序列收敛为零。”（MathWorld 的 Margherita Barile）^[4]
- commons:Category:Hawaiian earrings
Gevrey 渐近展开
- (7.1) 在原点的 Écalle-Voronin 不变量具有 Gevrey- 1/2 渐近展开^[5]
胚芽^[6]^[7]^[8]
- 函数的胚芽：函数的泰勒展开
重数^[9]
Julia-Lavaurs 集
Leau-Fatou 花定理：^[10] 排斥或吸引花。花由花瓣组成
- Leau-Fatou 花
抛物线线性化定理
喇叭映射
Blaschke 积
Inou 和 Shishikura 的近抛物线重整化
复多项式向量场^[11]
数字
- “一个正整数 ν，即 **抛物线退化**，具有以下性质：存在 νq 个吸引花瓣和 νq 个排斥花瓣，它们围绕不动点交替循环。”^[12]
- 组合旋转数
函数 f 在抛物线不动点处的庞加莱线性化器^[13]
“抛物线铅笔。这是一个圆族，它们都有一个共同点，因此彼此相切，内部或外部。”^[14]

Leau-Fatou 花定理

Leau-Fatou 花定理指出，如果函数 $f^{n}$ 具有泰勒展开^[15]

$f^{n}(z)=z+az^{n+1}+O(z^{n+2})$

则复数 $v$ 在单位圆上 $v\in S^{1}$ 描述单位向量（方向）

如果 $nav^{n}=1$ ，则 f 在原点处的排斥向量（从原点到 v）
如果 $nav^{n}=-1$ ，则吸引向量（从 v 到原点）

存在 n 个等距的吸引方向，由 n 个等距的排斥方向隔开。整数 n+1 称为不动点的重数

示例

函数展开：z+z^5

/* Maxima CAS */
display2d:false;
taylor(z+z^5, z,0,5);
                                
z + z^5

所以

a = 1
n = 4

计算吸引方向

/* Maxima CAS */
solve (4*v^4 = 1, v);

[v = %i/sqrt(2),v = -1/sqrt(2),v = -%i/sqrt(2),v = 1/sqrt(2)]

函数 m*z+z^2

(%i7) taylor(m*z+z^2, z,0,5);
(%o7) m*z+z^2

所以

a = 1
n = 1

(%i9) solve (v = 1, v);
(%o9) [v = 1]

Ecalle 柱面

Ecalle 柱面^[16] 或 Ecalle-Voronin 柱面（由 Jean Ecalle^[17]^[18])^[19]

“... 在将 z 和 f(z) 等同（如果 z 和 f(z) 都属于 P）的等价关系下，花瓣 P 的商。这个商流形称为 Ecalle 柱面，它与无限柱面 C/Z 构形同构。”^[20]

搅拌器动力学

手动打蛋器
以下是对抛物线情况下发生的真实模型

物理模型：使用打蛋器时蛋糕的行为。

数学模型：具有 2 个中心（二阶退化点）的二维向量场^[21]^[22]

该场围绕中心旋转，但似乎没有发散。

也许对抛物线动力学的更好描述是夏威夷耳环

抛物线胚芽

胚芽：^[23]^[24]^[25]

z+z^2
z+z^3
z+z^{k+1}
z+a_{k+1}z^{k+1}
z+a_{k+1}z^{k+1}
"胚芽 $f(x)=a_{1}x+a_{2}x^{2}+\ldots$ 与 $\vert a_{1}\vert \neq 0,1$ $\vert a_{1}\vert \neq 0,1$ 通过全纯共轭到其线性部分 $g(x)=a_{1}z$ " (Sylvain Bonnot)^[26]

向量场的胚芽

喇叭映射

"喇叭映射 h = Φ ◦ Ψ，其中 Φ 是 Φattr 的简写，Ψ 是 Ψrep 的简写（扩展的 Fatou 坐标和参数化）。"^[27]

花瓣

"花瓣是由 $f^{q}$ 不变的 Jordan 域。" R PEREZ-MARCO^[28]
花瓣是一个陷阱，它捕获任何趋向于抛物线点的轨道
花瓣是花的一部分

萼片

定义

萼片是吸引花瓣和排斥花瓣的交点。抛物线 Pommerenke-Levin-Yoccoz 不等式。由 Xavier Buf 和 Adam L. Epstein 似乎没有萼片的正式定义。
"设 l 是第一象限中的不变曲线，L1 是 l ∪ {0} 包围的区域，称为萼片。"^[29]
包含抛物线不动点的边界上的分量的内部

花

Lea-Fatu 花
具有四个花瓣和中心为抛物线点的花
内部角为 1/5 的临界轨道，显示 5 个吸引方向

所有花瓣的总和形成一朵花^[30]，中心位于抛物线周期点。^[31]

花椰菜

花椰菜或西兰花：^[32]

空（其内部为空）对于 Mandelbrot 集之外的 c。Julia 集是完全不连通的。
对于 Mandelbrot 集边界上的 c=1/4，填充的花椰菜。Julia 集是 Jordan 曲线（准圆）。

c = 0 < 1/4
c = 0.25 = 1/4 是主心形的根。Julia 集是花椰菜。
c = 0.255 > 1/4 "内爆的花椰菜"
c = 0.258 > 1/4
c = [0.285, 0.01]

请注意

图像大小因 z 平面不同而异。
使用了不同的算法，因此颜色很难比较。

花椰菜的分岔

Julia 集如何沿着实轴变化（从 c=0 到 c=1/4，然后更远）

扰动函数 $f(z)$ 由复数 $\epsilon$

$g(z)=f(z)+\epsilon$

当添加一个大于0的ε（沿实轴向正无穷大移动）时，会出现一个抛物型不动点的分叉

吸引不动点 (ε<0)
一个抛物型不动点 (ε = 0)
一个抛物型不动点分裂成两个共轭排斥不动点 (ε > 0)

“如果我们用ε<0稍微扰动，那么抛物型不动点将在实轴上分裂成两个实不动点（一个吸引，一个排斥）。”

参见

Wolf Jung 的 Mandel 程序中的演示 2，第 9 页

抛物线内爆

抛物型内爆

在参数平面中
- 点 c 从分量的内部，穿过边界，到曼德尔布罗特集的外部
- 核 (c=0)，沿内部射线 0，抛物点 (c= 0.25)，沿外部射线 0
在动力学平面中
- 连接的朱利亚集（有内部）内爆，并断开连接（没有内部）
- 不动点从内部移动到朱利亚集（抛物型）
- 一个盆地（内部）消失

沿逃逸路径 0 的动力学演化（抛物型内爆）
参数 c	位置	朱利亚集	内部	动力学类型	临界点	不动点
c = 0	中心，内部	连接的	存在	超吸引	被吸引到 alfa 不动点	固定临界点等于 alfa 不动点，alfa 是超吸引的，beta 是排斥的
0<c<1/4	内部射线 0，内部	连接的	存在	吸引	被吸引到 alfa 不动点	alfa 是吸引的，beta 是排斥的
c = 1/4	尖点，边界	连接的	存在	抛物型	被吸引到 alfa 不动点	alfa 不动点等于 beta 不动点，两者都是抛物型的
c>1/4	外部射线 0，外部	断开连接的	消失	-	排斥到无穷大	两个有限不动点都是排斥的

YouTube 上的视频^[33]

抛物型内爆：从圆形到花椰菜，再到内爆的花椰菜
c=0
c=1/4
c= 1/4 + 0.05
c = 1/4 + 0.029
c = 1/4 + 0.035

向量场

二维向量场及其

奇点

奇点类型

中心类型：“在这种情况下，可以找到奇点的邻域，其中所有积分曲线都是封闭的，彼此嵌套，并在其内部包含奇点”^[34]
非中心类型：奇点的邻域由几个曲线扇区组成：^[35]

“曲线扇区定义为由半径任意小的圆 C 和两个流线 S 和 S! 围成的区域，这两个流线都收敛到奇点。然后考虑通过开扇区 g 的流线，以区分三种可能的曲线扇区类型。”

动力学

全局
局部

局部动力学

在朱利亚集的外部
在朱利亚集上
靠近抛物型不动点（在朱利亚集内部）

另请参阅

youtube 播放列表：ODTWÓRZ WSZYSTKIE Corinna Ulcigrai - 来自高等科学研究院 (IHÉS) 的抛物型动力学和重整化

靠近抛物型不动点

为什么分析 f^p 而不是 f？

f 靠近抛物型不动点的正向轨道是复合的。它由两种运动组成

围绕不动点
向不动点移动/远离不动点

如何计算抛物型 c 值

使用边界方程计算参数

抛物型参数的类型

根点
尖点

曼德尔布罗特集（参数平面）的周期 1 分量的抛物点
n	内部角（旋转数）t = 1/n	根点 c = 抛物型参数	落在根点 c 上的参数射线的两个外部角（1/(2^n+1); 2/(2^n+1)	不动点 $z_{\alpha }$	落在不动点 $z_{\alpha }$
1	1/1	0.25	(0/1 ; 1/1)	0.5	(0/1 = 1/1)
2	1/2	-0.75	(1/3; 2/3)	-0.5	(1/3; 2/3)
3	1/3	0.64951905283833*%i-0.125	(1/7; 2/7)	0.43301270189222*%i-0.25	(1/7; 2/7; 3/7)
4	1/4	0.5*%i+0.25	(1/15; 2/15)	0.5*%i	(1/15; 2/15; 4/15; 8/15)
5	1/5	0.32858194507446*%i+0.35676274578121	(1/31; 2/31)	0.47552825814758*%i+0.15450849718747	(1/31; 2/31; 4/31; 8/31; 16/31)
6	1/6	0.21650635094611*%i+0.375	(1/63; 2/63)	0.43301270189222*%i+0.25	(1/63; 2/63; 4/63; 8/63; 16/63; 32/63)
7	1/7	0.14718376318856*%i+0.36737513441845	(1/127; 2/127)	0.39091574123401*%i+0.31174490092937	(1/127; 2/127, 4/127; 8/127; 16/127; 32/127, 64/127)
8	1/8	0.10355339059327*%i+0.35355339059327		0.35355339059327*%i+0.35355339059327
9	1/9	0.075191866590218*%i+0.33961017714276		0.32139380484327*%i+0.38302222155949
10	1/10	0.056128497072448*%i+0.32725424859374		0.29389262614624*%i+0.40450849718747

对于内部角 n/p 抛物周期 p 循环，它包含一个具有 p 重数的 z 点^[36] 和一个乘子 = 1.0。这个点 z 等于不动点 $z_{alfa}$

周期 1

可以轻松计算边界点 c

$c=c_{x}+c_{y}*i$

对于给定的内部角（旋转数）t，使用 Wolf Jung 编写的这段cpp 代码^[37]

 t *= (2*PI); // from turns to radians
 cx = 0.5*cos(t) - 0.25*cos(2*t); 
 cy = 0.5*sin(t) - 0.25*sin(2*t);

或这段 Maxima CAS 代码

 
/* conformal map from circle to cardioid ( boundary
 of period 1 component of Mandelbrot set */
F(w):=w/2-w*w/4;

/* 
circle D={w:abs(w)=1 } where w=l(t,r) 
t is angle in turns ; 1 turn = 360 degree = 2*Pi radians 
r is a radius 
*/
ToCircle(t,r):=r*%e^(%i*t*2*%pi);

GiveC(angle,radius):=
(
 [w],
 /* point of  unit circle   w:l(internalAngle,internalRadius); */
 w:ToCircle(angle,radius),  /* point of circle */
 float(rectform(F(w)))    /* point on boundary of period 1 component of Mandelbrot set */
)$

compile(all)$

/* ---------- global constants & var ---------------------------*/
Numerator: 1;
DenominatorMax: 10;
InternalRadius: 1;

/* --------- main -------------- */
for Denominator:1 thru DenominatorMax step 1 do
(
 InternalAngle: Numerator/Denominator,
 c: GiveC(InternalAngle,InternalRadius),
 display(Denominator),
 display(c),
  /* compute fixed point */
 alfa:float(rectform((1-sqrt(1-4*c))/2)), /* alfa fixed point */
 display(alfa)
)$

周期 2

// cpp code by W Jung http://www.mndynamics.com
 t *= (2*PI);  // from turns to radians
 cx = 0.25*cos(t) - 1.0;
 cy = 0.25*sin(t);

周期 1-6

/*

batch file for Maxima CAS 
computing bifurcation points for period 1-6

 Formulae for cycles in the Mandelbrot set II
Stephenson, John; Ridgway, Douglas T.
Physica A, Volume 190, Issue 1-2, p. 104-116.
*/

kill(all);
remvalue(all);

start:elapsed_run_time ();

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

/* exponential for of complex number with angle in turns */
 /* "exponential form prevents allroots from working", code by Robert P. Munafo */

GivePoint(Radius,t):=rectform(ev(Radius*%e^(%i*t*2*%pi), numer))$ /* gives point of unit circle for angle t in turns */

GiveCirclePoint(t):=rectform(ev(%e^(%i*t*2*%pi), numer))$ /* gives point of unit circle for angle t in turns Radius = 1 */

/* gives a list of iMax points of unit circle */
GiveCirclePoints(iMax):=block(
 [circle_angles,CirclePoints],
 CirclePoints:[],
 circle_angles:makelist(i/iMax,i,0,iMax),
 for t in circle_angles do CirclePoints:cons(GivePoint(1,t),CirclePoints),
 return(CirclePoints) /* multipliers */
)$

/* http://commons.wikimedia.org/wiki/File:Mandelbrot_set_Components.jpg 
Boundary equation  b_n(c,P)=0 
    defines relations between hyperbolic components and unit circle for given period n ,
    allows computation of exact coordinates of hyperbolic componenets.

b_n(w,c), is boundary polynomial (implicit function of 2 variables).

*/

GiveBoundaryEq(P,n):=
block(
 if n=1 then return(c + P^2 - P),
 if n=2 then return(- c + P - 1),
 if n=3 then return(c^3 + 2*c^2 - (P-1)*c + (P-1)^2),
 if n=4 then return(c^6 + 3*c^5 + (P+3)* c^4 + (P+3)* c^3 - (P+2)*(P-1)*c^2 - (P-1)^3),
 if n=5 then return(c^15 + 8*c^14 + 28*c^13 + (P + 60)*c^12 + (7*P + 94)*c^11 + 
  (3*P^2 + 20*P + 116)*c^10 + (11*P^2 + 33*P + 114)*c^9 + (6*P^2 + 40*P + 94)*c^8 + 
  (2*P^3 - 20*P^2 + 37*P + 69)*c^7 + (3*P - 11)*(3*P^2 - 3*P - 4)*c^6 + (P - 1)*(3*P^3 + 20*P^2 - 33*P - 26)*c^5 +
  (3*P^2 + 27*P + 14)*(P - 1)^2*c^4 - (6*P + 5)*(P - 1)^3*c^3 + (P + 2)*(P - 1)^4*c^2 - c*(P - 1)^5  + (P - 1)^6),
if n=6 then return (c^27+
13*c^26+
78*c^25+
(293 - P)*c^24+
(792 - 10*P)*c^23+
(1672 - 41*P)*c^22+
(2892 - 84*P - 4*P^2)*c^21+
(4219 - 60*P - 30*P^2)*c^20+
(5313 + 155*P - 80*P^2)*c^19+
(5892 + 642*P - 57*P^2 + 4*P^3)*c^18+
(5843 + 1347*P + 195*P^2 + 22*P^3)*c^17+
(5258 + 2036*P + 734*P^2 + 22*P^3)*c^16+
(4346 + 2455*P + 1441*P^2 - 112*P^3 + 6*P^4)*c^15 + 
(3310 + 2522*P + 1941*P^2 - 441*P^3 + 20*P^4)*c^14 + 
(2331 + 2272*P + 1881*P^2 - 853*P^3 - 15*P^4)*c^13 + 
(1525 + 1842*P + 1344*P^2 - 1157*P^3 - 124*P^4 - 6*P^5)*c^12 + 
(927 + 1385*P + 570*P^2 - 1143*P^3 - 189*P^4 - 14*P^5)*c^11 + 
(536 + 923*P - 126*P^2 - 774*P^3 - 186*P^4 + 11*P^5)*c^10 + 
(298 + 834*P + 367*P^2 + 45*P^3 - 4*P^4 + 4*P^5)*(1-P)*c^9 + 
(155 + 445*P - 148*P^2 - 109*P^3 + 103*P^4 + 2*P^5)*(1-P)*c^8 + 
2*(38 + 142*P - 37*P^2 - 62*P^3 + 17*P^4)*(1-P)^2*c^7 + 
(35 + 166*P + 18*P^2 - 75*P^3 - 4*P^4)*((1-P)^3)*c^6 + 
(17 + 94*P + 62*P^2 + 2*P^3)*((1-P)^4)*c^5 + 
(7 + 34*P + 8*P^2)*((1-P)^5)*c^4 + 
(3 + 10*P + P^2)*((1-P)^6)*c^3 + 
(1 + P)*((1-P)^7)*c^2 +
-c*((1-P)^8) + (1-P)^9)
)$

/* gives a list of points c on boundaries on all components for give period */
GiveBoundaryPoints(period,Circle_Points):=block(
 [Boundary,P,eq,roots],
  Boundary:[],
 for m in Circle_Points do (/* map from reference plane to parameter plane */
  P:m/2^period,
  eq:GiveBoundaryEq(P,period), /* Boundary equation  b_n(c,P)=0  */
  roots:bfallroots(%i*eq),
  roots:map(rhs,roots),
  for root in roots do Boundary:cons(root,Boundary)),
  return(Boundary)
)$

/* divide llist of roots to 3 sublists = 3  components */
/* ---- boundaries of period 3 components 
period:3$
Boundary3Left:[]$
Boundary3Up:[]$
Boundary3Down:[]$

Radius:1;

 for m in CirclePoints do (
  P:m/2^period,
  eq:GiveBoundaryEq(P,period),
  roots:bfallroots(%i*eq),
  roots:map(rhs,roots),
  for root in roots do 
     (
       if realpart(root)<-1  then Boundary3Left:cons(root,Boundary3Left),
       if (realpart(root)>-1 and imagpart(root)>0.5) 
            then Boundary3Up:cons(root,Boundary3Up),
       if (realpart(root)>-1 and imagpart(root)<0.5) 
            then Boundary3Down:cons(root,Boundary3Down)
               
     )

)$
--------- */

/* gives a list of parabolic points for given: period and internal angle */
GiveParabolicPoints(period,t):=block
(
 [m,ParabolicPoints,P,eq,roots],
 m: GiveCirclePoint(t), /* root of unit circle, Radius=1, angle t=0 */
 ParabolicPoints:[],
 /* map from reference plane to parameter plane */
 P:m/2^period,
 eq:GiveBoundaryEq(P,period), /* Boundary equation  b_n(c,P)=0  */
 roots:bfallroots(%i*eq),
 roots:map(rhs,roots),
 for root in roots do ParabolicPoints:cons(float(root),ParabolicPoints),
 return(ParabolicPoints)

)$

compile(all)$

/* ------------- constant values ----------------------*/

fpprec:16;

/* ------------unit circle on a w-plane -----------------------------------------*/
a:GiveParabolicPoints(6,1/3);
a$

周期 d

/*
gcc c.c -lm -Wall
./a.out
Root point between period 1 component and period 987 component  = c = 0.2500101310666710+0.0000000644946597
Internal angle (c) = 1/987
Internal radius (c) = 1.0000000000000000

*/

#include <stdio.h>
#include <math.h>		// M_PI; needs -lm also
#include <complex.h>



/* 
   c functions using complex type numbers
   computes c from  component  of Mandelbrot set */
complex double Give_c( int Period,  int n, int d , double InternalRadius )
{
  complex double c; 
  complex double w;  // point of reference plane  where image of the component is a unit disk 
 // alfa = ax +ay*i = (1-sqrt(d))/2 ; // result 
  double t; // InternalAngleInTurns
  
  t  = (double) n/d; 
  t = t * M_PI * 2.0; // from turns to radians
  
  w = InternalRadius*cexp(I*t); // map to the unit disk 
  
  switch ( Period ) // of component 
    {
    case 1: // main cardioid = only one period 1 component
      c = w/2 - w*w/4; // https://wikibooks.cn/wiki/Fractals/Iterations_in_the_complex_plane/Mandelbrot_set/boundary#Solving_system_of_equation_for_period_1
      break;
    case 2: // only one period 2 component 
      c = (w-4)/4 ; // https://wikibooks.cn/wiki/Fractals/Iterations_in_the_complex_plane/Mandelbrot_set/boundary#Solving_system_of_equation_for_period_2
      break;
      // period > 2 
    default: 
      printf("higher periods : to do, use newton method \n");
      printf("for each q = Period of the Child component  there are 2^(q-1) roots \n");
      c = 10000.0; // bad value 
       
      break; }
      
      
  return c;
}



void PrintAndDescribe_c( int period,  int n, int d , double InternalRadius ){


	complex double c = Give_c(period, n, d, InternalRadius);
	
	printf("Root point between period %d component and period %d component  = c = %.16f%+.16f*I\t",period, d, creal(c), cimag(c));
	printf("Internal angle (c) = %d/%d\n",n, d);
	//printf("Internal radius (c) = %.16f\n",InternalRadius);



}

/*
https://stackoverflow.com/questions/19738919/gcd-function-for-c
The GCD function uses Euclid's Algorithm. 
It computes A mod B, then swaps A and B with an XOR swap.
*/

int gcd(int a, int b)
{
    int temp;
    while (b != 0)
    {
        temp = a % b;

        a = b;
        b = temp;
    }
    return a;
}





int main (){


	int period = 1;
	double InternalRadius = 1.0;
	// internal angle in turns as a ratio = p/q
	int n = 1;
	int d = 987;
	
	
	
	
	
	// n/d = local angle in turns
 	
   		for (n = 1; n < d; ++n ){
     			if (gcd(n,d)==1 )// irreducible fraction
       				{ PrintAndDescribe_c(period, n,d,InternalRadius); }
       				}
       		
	
	



	return 0;

}

如何绘制抛物线朱利亚集

5 种绘制方法
检查迭代次数
修改后的 DEM
检查角度
检查 zn 是否在目标集内
检查 zn 是否在三角形目标集内

填充朱利亚集内部的所有点都趋向于一个周期轨道（或不动点）。此点位于朱利亚集中，并且是弱吸引的。^[38] 您可以分析抛物线不动点附近的行为。可以使用临界轨道来完成此操作。

这里有两种情况：简单和困难。

如果抛物线不动点附近的朱利亚集类似于 n 臂星形（未扭曲），则您可以简单地检查 zn 相对于不动点的幅角。例如，请参见 z+z^5。这是一个简单的例子。

在困难的情况下，朱利亚集围绕不动点扭曲。

拓扑

根点的朱利亚集在拓扑上与子周期中心的朱利亚集相同，但

中心（核）朱利亚集非常容易绘制（超吸引盆 = 非常快的动态，因为临界点也是周期点）
而根朱利亚集（抛物线）很难绘制（抛物线盆和懒惰动态）

示例

t = 1/2
- 根点的朱利亚集 = 胖巴塞利卡朱利亚集：c = -3/4 = - 0.75
- 周期 2 中心的朱利亚集 = （细长）巴塞利卡朱利亚集：c = -1
t = 1/3
- 根点的朱利亚集 = 胖杜阿迪兔子：c = -0.125000000000000 +0.649519052838329i
- 周期 3 中心的朱利亚集 = （细长）杜阿迪兔子朱利亚集：c = -0.122561166876654 +0.744861766619744i 周期 = 3

从外部估计

逃逸时间

描述

长迭代或大步法

描述

长迭代法^[39]
大步算法^[40]

步骤

选择函数 $f$ ，其在原点（z=0）处有一个固定抛物线点
选择内部角度 $\theta ={\frac {m}{k}}$
计算 $F_{k}$ ，它是函数 $f$ 的较高迭代次数的近似值，z 接近于零，使用以零为中心的幂级数（泰勒级数 = 麦克劳林级数）
实验性地找出使用幂级数的项数以及使用特定 $F_{k}$ 的环带

 $F_{k}\approx f^{2^{k}}$

每个 $F_{k}$ 将被用于一个环带

${\frac {1}{2^{k+K+1}}}<|z|<{\frac {1}{2^{k+K}}}$

其中 K 为固定值

示例

具有在原点处具有乘子 $\lambda$ 的无差异不动点的复二次多项式的 Lambda 形式^[41]

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

其中

定点的乘数 $\lambda =e^{2\pi \theta i}$
内角是一个有理数和真分数 $\theta ={\frac {m}{k}}$

选择

$\theta ={\frac {1}{7}}$ 因此 $\lambda =e^{(2\pi i)/7}$
幂级数的30项
环k=4,5,...,10的近似函数，对于z的较大值（在环外），使用默认函数f^n
函数的delta等于10^-5

(* code by Professor: Mark McClure from https://marksmath.org/classes/Spring2019ComplexDynamics/ *)
n = 7;
f[z_] = Exp[2 Pi*I/n] z + z^2;

Remove[F];
F[0][z_]    = N[Normal[Series[f[z], {z, 0, 30}]]];
Do[F[0][z_] = Chop[N[Normal[Series[F[0][f[z]], {z, 0, 30}]]], 10^-5],  {n - 1}];
Do[F[k][z_] = Chop[N[Normal[Series[F[k - 1][F[k - 1][z]], {z, 0, 30}]]], 10^-5], {k, 1, 10}]

(* define and compile function FF *)
FF = With[{
    n = n,
    f4 = Function[z, Evaluate[F[4][z]]],
    f5 = Function[z, Evaluate[F[5][z]]],
    f6 = Function[z, Evaluate[F[6][z]]],
    f7 = Function[z, Evaluate[F[7][z]]],
    f8 = Function[z, Evaluate[F[8][z]]],
    f9 = Function[z, Evaluate[F[9][z]]],
    f10 = Function[z, Evaluate[F[10][z]]]
    },
   Compile[{{z, _Complex}},
    Which[
     Abs[z] > 1/2^3, 
     Nest[Function[zz, N[Exp[2 Pi*I/n]] zz + zz^2], z, n],
     Abs[z] <= 1/2^9, f10[z],
     Abs[z] <= 1/2^8, f9[z],
     Abs[z] <= 1/2^7, f8[z],
     Abs[z] <= 1/2^6, f7[z],
     Abs[z] <= 1/2^5, f6[z],
     Abs[z] <= 1/2^4, f5[z],
     Abs[z] <= 1/2^3, f4[z],
     True, 0]]];
     
(* iterate 1000 times and then see what happens *)
iterate = With[{FF = FF, n = n},
   Compile[{{z0, _Complex}},
    Module[{z, i},
     z = z0;
     i = 0;
     While[1/2^9 < Abs[z] <= 2 && i++ < 1000 n,
      z = FF[z]];
     z],
    RuntimeOptions -> "Speed", CompilationTarget -> "C"]];

(* now compute some iteration data *)
data = Monitor[
    Table[iterate[x + I*y], {y, Im[center] + 1.2, Im[center], -0.0025},
     {x, Re[center] - 1.2, Re[center] + 1.2, 0.0025}], 
    y]; 


(* use some symmetry to cut computation time in half *)
center = First[Select[z /. NSolve[f[z] == 0, z], Im[#] < 0 &]]/2 (* center = -0.311745 - 0.390916*I *)
data = Join[data, Reverse[Rest[Reverse /@ data]]];


(* plot it  *)
kernel = {
   {1, 1, 1},
   {1, -8, 1},
   {1, 1, 1}
   };
   
 (*   
classifyArg = Compile[
   {{z, _Complex}, {z0, _Complex}, {v, _Complex}, {n, _Integer}},
   Module[{check, check2},
    check = n (Arg[(z0 - z)/v] + Pi)/(2 Pi);
    check2 = Ceiling[check];
    If[check == check2, 0, check2]]];   
   
   
   
classified = Map[classify, data, {2}];

convolvedData = ListConvolve[kernel, classified];

ArrayPlot[Sign[Abs[convolvedData]]]

Wolfram 语言的数学函数（

Series[f,{x,x0,n}] 生成关于点 $x=x_{0}$ 的f的幂级数展开，阶数为 $(x-x_{0})^{n}$ ，其中n是一个明确的整数
N[expr] 给出expr的数值
Chop[expr,delta] 将绝对值小于delta的数字替换为0
Normal[expr] 将expr从各种特殊形式转换为正常表达式。
Do[expr,n] 评估expr n次
Do[expr,{i,imin,imax}] 评估expr，从i=imin开始
With[{x=x0,y=y0,…},expr] 指定expr中所有x、y等的出现应该被替换为x0、y0等。
Compile[{{x1,t1},…},expr] 假设xi的类型与ti匹配。
Which[test1,value1,test2,value2,…] 依次评估每个testi，返回第一个产生True的valuei的值
Nest[f,expr,n] 给出对expr应用n次f的表达式。

动态射线

可以使用落在抛物线不动点的周期性动态射线来寻找外部的狭窄部分。

让我们检查外部半径=4的周期性射线上的点需要多少次反向迭代才能到达距离抛物线不动点0.003的位置

周期	反向迭代	时间
1	340	0m0.021s
2	55 573	0m5.517s
3	8 084 815	13m13.800s
4	1 059 839 105	1724m28.990s

可以使用外部射线的点z的幅角及其到alfa不动点的距离（参见图像中的代码）。它适用于周期数不超过15（也许更多……）。

从内部估计

朱利亚集是填充的朱利亚集Kc的边界。

找到Kc内部的点
使用边缘检测找到Kc内部的边界

如果内部的组件彼此非常接近，则使用以下方法找到组件：^[42]

color = LastIteration % period

对于父组件和子组件之间的抛物线组件：^[43]

periodOfChild = denominator*periodOfParent  
color = iLastIteration % periodOfChild

其中分母是曼德勃罗集的父组件的内角的分母。

角度

"如果zn的迭代趋于一个固定的抛物点，那么初始种子z0根据zn−z0的幅角进行分类，分类由花定理提供"(Mark McClure^[44])

吸引时间

填充的朱利亚集的内部由组件组成。所有组件都是前周期的，其中一些是周期的（吸引力的直接盆地）。

换句话说

一次迭代将z移动到另一个组件（以及整个组件移动到另一个组件）
所有组件的点都具有相同的吸引时间（到达吸引子周围的目标集所需的迭代次数）

可以使用它来对组件进行着色。因为在抛物线情况下吸引子是弱的（弱吸引），所以某些点需要很多次迭代才能到达它。

 // i = number of iteration
 // iPeriodChild = period of child component of Mandelbrot set ( parabolic c value is a root point between parant and child component
 /* distance from z to Alpha  */
 Zxt=Zx-dAlfaX;
 Zyt=Zy-dAlfaY;
 d2=Zxt*Zxt +Zyt*Zyt;
 // interior: check if fall into internal target set (circle around alfa fixed point)  
 if (d2<dMaxDistance2Alfa2) return  iColorsOfInterior[i % iPeriodChild];

这里有一些示例值

 iWidth  = 1001 // width of image in pixels
 PixelWidth  = 0.003996  
 AR  = 0.003996 // Radius around attractor
 denominator  = 1 ; Cx  = 0.250000000000000; Cy  = 0.000000000000000 ax  = 0.500000000000000; ay  = 0.000000000000000   
 denominator  = 2 ; Cx  = -0.750000000000000; Cy  = 0.000000000000000 ax  = -0.500000000000000; ay  = 0.000000000000000   
 denominator  = 3 ; Cx  = -0.125000000000000; Cy  = 0.649519052838329 ax  = -0.250000000000000; ay  = 0.433012701892219  
 denominator  = 4 ; Cx  = 0.250000000000000; Cy  = 0.500000000000000 ax  = 0.000000000000000; ay  = 0.500000000000000   
 denominator  = 5 ; Cx  = 0.356762745781211; Cy  = 0.328581945074458 ax  = 0.154508497187474; ay  = 0.475528258147577   
 denominator  = 6 ; Cx  = 0.375000000000000; Cy  = 0.216506350946110 ax  = 0.250000000000000; ay  = 0.433012701892219    
 
 denominator  = 1 ;   i =               243.000000 
 denominator  = 2 ;   i =            31 171.000000 
 denominator  = 3 ;   i =         3 400 099.000000 
 denominator  = 4 ;   i =       333 293 206.000000 
 denominator  = 5 ;   i =    29 519 565 177.000000 
 denominator  = 6 ;   i = 2 384 557 783 634.000000

其中

C = Cx + Cy*i 
a = ax + ay*i // fixed point alpha
i // number of iterations after which critical point z=0.0 reaches disc around fixed point alpha with radius AR
denominator of internal angle (in turns)
internal angle = 1/denominator

请注意，吸引时间i与分母成正比。

现在您看到了弱吸引意味着什么。

你可以

使用蛮力方法（吸引半径<像素大小；迭代最大值足够大，让内部的所有点都到达目标集；长时间或快速计算机）
找到更好的方法（:-))，如果您觉得时间太长

内部距离估计

陷阱

从内部和外部估计

Julia 集是填充的 Julia 集和无穷大吸引域的共同边界。

找到 Kc 内部/分量的点
找到逃逸点
使用 Sobel 滤波器找到边界点

它适用于分母不超过 4。

排斥点的逆迭代

逆迭代阿尔法不动点。它只对切割点（外部射线落入的地方）有效。其他点仍然没有被击中。

Bof61

画廊

一个临界点情况下临界轨道
从 1/1 到 1/10 的内部角度的临界轨道。真吸引方向
从 1 到 10 的 n 星形臂。示意吸引方向
内部角度为 1/3 的临界轨道、吸引向量和排斥向量

从周期 1 到 ...
1/1 花椰菜
$1/2 San Marco fractal[45]$

1/2 圣马可分形^[45]
1/3 杜瓦迪肥兔子^[46]
1/4
1/5
1/7
1/10
1/15
1/20
1/30

从周期 2 到 ...
$from 2 thru internal ray 1/1 ; c=-0.75 Julia set is a San Marco fractal[47]$

从 2 到内部射线 1/1 ; c=-0.75 Julia 集是一个 圣马可分形^[47]
从周期 2 到 1/2
从周期 2 到 1/3
从周期 2 到 1/4

从周期 3 到 ...
从周期 3 到 1/3

外部示例

有关其他多项式映射，请参阅此处

另请参阅

参考文献

[1] Mark Braverman：关于抛物 Julia 集的有效计算

[2] 关于抛物线的动态稳定扰动的注记作者：河原智己

[3] 维基百科中的填充的 Julia 集

[4] Barile, Margherita. "夏威夷耳环。" 来自 MathWorld - Wolfram 网页资源，由 Eric W. Weisstein 创建。http://mathworld.wolfram.com/HawaiianEarring.html

[5] Augustin Fruchard, Reinhard Sch¨afke. 复合渐近展开和差分方程。应用信息学与数学非洲研究评论，INRIA，2015，20，pp.63-93。<hal-01320625>

[6] 维基百科：胚芽 (数学)

[7] 微分同胚的不动点、向量场的奇点及其轨道的 epsilon 邻域作者：Maja Resman

[8] 展开抛物不动点的解析微分同胚胚芽族模空间作者：Colin Christopher，Christiane Rousseau

[9] 维基百科：重数 (数学)

[10] 表面同胚的动力学 Leau-Fatou 花定理和稳定流形定理的拓扑版本作者：Le Roux，F

[11] C 中复多项式向量场的动力学作者：Kealey Dias

[12] 退化抛物二次有理映射的极限作者：XAVIER BUFF、JEAN ECALLE 和 ADAM EPSTEIN

[13] 更高维的庞加莱线性化作者：Alastair Fletcher

[14] 圆的铅笔作者：James King

[15] th.stackexchange 问题：抛物临界轨道的形状是什么

[16] 全纯不变量理论。国家论文，奥赛，1974 年 3 月

[17] 法语维基百科中的让·埃卡勒

[18] 让·埃卡勒主页

[19] 卢卡斯·盖耶 - 通过一致化实现的标准形式 (2016 年 10 月 28 日)。这是使用一致化定理证明吸引、排斥和抛物不动点局部标准形式的草案，在课堂上分发。最终它将被纳入讲义。

[20] 映射作者：Luna Lomonaco

[21] 通用抛物微分同胚展开的解析分类模作者：P. Mardesic、R. Roussarie¤ 和 C. Rousseau

[22] thoverflow 问题：函数方程 ffxxfx2

[23] 维基百科中的胚芽

[24] 通用抛物微分同胚展开的解析分类模作者：P. Mardesic、R. Roussarie 和 C. Rousseau

[25] 展开抛物不动点的解析微分同胚胚芽族模空间作者：Colin Christopher，Christiane Rousseau

[26] Mathoverflow：在固定点附近函数的无穷小分类，直到共轭

[27] 单奇异全纯映射的近抛物重整化作者：Arnaud Cheritat

[28] Ricardo Pérez-Marco. "不动点和圆周映射." Acta Math. 179 (2) 243 - 294, 1997. https://doi.org/10.1007/BF02392745

[29] 关于抛物线的动态稳定扰动的注记由川平知己

[30] 抛物不动点：Leau-Fatou 花由 Davide Legacci 2021 年 3 月 18 日

[31] 维基百科：玫瑰 (拓扑)

[32] 花椰菜在 MuEncy 由 Robert Munafo

[33] 圆圈内爆成火焰 - 视频由 sinflrobot

[34] 二维向量场的拓扑简化方法由 Xavier Tricoche Gerik Scheuermann Hans Hagen

[35] 数学百科：常微分方程理论中的扇形

[36] 维基百科：数学中的重数

[37] Mandel：用于实数和复数动力学的软件由 Wolf Jung

[38] 不动点处的局部动力学由 Evgeny Demidov

[39] 抛物型朱利亚集是多项式时间可计算的由 Mark Braverman

[40] Mark McClure 春季课程 2019：复数动力学，参见代码“抛物点附近的迭代”（Mathematica 笔记本）

[41] Michael Yampolsky, Saeed Zakeri：配对西格尔二次多项式。

[42] 不动点和周期轨道由 Evgeny Demidov

[43] 绘制抛物型朱利亚集的 C 程序源代码

[44] Stack Exchange 问题：抛物型临界轨道的形状是什么？

[45] PlanetMath：圣马可分形

[46] 维基百科：杜阿迪兔子

[47] PlanetMath：圣马可分形

[48] 图片：非标准抛物线由 Cheritat

[49] Maxima CAS 中的抛物型情况下的朱利亚集

[1]

[2]

[3]

[4]

[5]

[6]

[7]

[8]

[9]

[10]

[11]

[12]

[13]

[14]

[15]

[16]

[17]

[18]

[19]

[20]

[21]

[22]

[23]

[24]

[25]

[26]

[27]

[28]

[29]

[30]

[31]

[32]

[33]

[34]

[35]

[36]

[37]

[42]

[43]

[44]

[45]

[46]

[47]

[48]

[49]