The Cauliflower fractal is generated by two simple linear transformation
in the plane. To be more precise two mappings of the unit circle in
itself. One mapping, maps the unit circle to a smaller circle with radius

touching
the unit circle. This represents the fact that a small piece of the
cabbage on the outside has the same form as the whole cabbage.
The other mapping, rotates and shrinks the unit circle into a circle
which has the same centre as the unit circle with radius *b*

,
and rotated along the angle *a*

. This represents the
fact that the rotated (and slightly shrinked) cauliflower looks the same
as the original. Below is the cauliflower fractal for *phi*

is
0.8, *a*

= 0.5, and *b*

= 140 degrees,
drawn inside the unit circle.
*phi*

*f*

, and *g*

is given
by:
/ x \ /The cauliflower fractalbx + 1 -b\ / x \ / 1 -b\f: | | = | | =b| | + | | \ y / \ by / \ y / \ 0 / / x \ | cos(phi) sin(phi) | / x \g: | | =a| | | | \ y / | -sin(phi) cos(phi) | \ y /

*L(a,b,phi)*

for `0<`*a*<1

, and `0<`*b*<1

is the set of points (inside the unit circle)
which is equal to union of the two sets of points which are made by
the mappings *f*

, and *g*

. Or in
mathematics:
Depending on the values ofL(a,b,phi)= {f(p) | pinL(a,b,phi)}union{g(p) | pinL(a,b,phi)}

*a*

, *b*

,
and *p*

, the resulting fractal will look more or less
like a cauliflower.
The construction of the set of points

is not trivial, because the set is an infinite set (except for some
rare cases). But it is possible to construct series of sets which
get closer and closer to this set. It is obvious that the points
*L(a,b,phi)*`(1, 0)`

and `(0, 0)`

are in

, as
*L(a,b,phi)*

maps *f*`(1, 0)`

on itself, and

maps *g*`(0, 0)`

on itself.
And if we know that a point `p`

is in

, we also know that the points
*L(a,b,phi)*

, and *f*(p)

are in
*g*(p)

. We can use this knowledge to create
ever greater sets of points which are a subset of the set we are
looking for.
*L(a,b,phi)*

One method is the so-called random-walk method, which can be easily
implemented. The idea is that you start with the point `(0, 0)`

,
and repeatedly apply one of the two mappings at random, to generate new
point. These points are plotted immediately.
An example, of a program which used this approach is the program
`kool.c`, which I wrote.
It is also possible to program this algorithm in the PostScript file `random.ps`.

Another way of generating the points is a recursive method, which
just finds all points starting from `(0, 0)`

, and
`(1, 0)`

after applying all possible combinations
of the mappings until a certain maximum length has been reached.
An example of this can be seen in the PostScript file
`dots.ps`.

The above methods generate sets which are subsets of

, but it is also possible to generate
a series of smaller and smaller sets which enclose
*L(a,b,phi)*

. It is clear, that *L(a,b,phi)*

is inside the unit circle (except for the point *L(a,b,phi)*`(1, 0)`

, which
is on the unit circle). If `C`

represents the
unit circle, then we know that _{u}

is
inside the union of *L(a,b,phi)*`C`

, and
_{f}=*f*(C_{u})`C`

.
The same applies to the set of circles
_{g}=*g*(C_{u})`C`

,
_{ff}=*f*(*f*(C_{u}))`C`

,
_{gf}=*f*(*g*(C_{u}))`C`

, and
_{fg}=*g*(*f*(C_{u}))`C`

,
which one gets by applying the
_{gg}=*g*(*g*(C_{u}))

, and *f*

to the circles
*g*`C`

, and _{f}`C`

.
An example of this can be seen in the PostScript file
_{g}`circles.ps`, which displays open
circles. In the PostScript file
`scircles.ps` a set of solid
circles is generated, where all circles are smaller than a given
dimension.

*a*

, and *b*

are
small, all the point in *L(a,b,phi)*

are
standing apart. Although each point is surrounded by an infinite
number of other points, it might seem if they are connected,
but zooming in, will always show that they are not connected to each
other. If *a*+2*b*

is smaller than 1,
it is obvious that the circles `C`_{f}

,
and `C`_{g}

do not touch. This means that all
the points of *L(a,b,phi)*

can be divided in
two groups, inside `C`_{g}

, and `C`_{g}

respectively, which are not connect. If we look inside circle
`C`_{f}

, we will see that the points inside this
circle are all inside `C`_{ff}

, and
`C`_{gf}

, which are two circles which are also not
touching each other. By this we can show that the condition
*a*+2*b*<1

implies that
*L(a,b,phi)*

can be divided in any arbitrary number of
sets of points, which are not connected.
Algebraic conditions for *L(a,b,phi)*

to be disconnected
are given below
For other values of

, *a*

, and
*b*

, it can be shown that all the points in
*phi*

are connect. Two points are considered
connected if there exists an line of points between them. This line,
which does not need to be straights, consists of an infinite number of
points, which have a complete ordering. Furthermore, it must be possible
to divide the line in segments, such that the points within each segment
are arbitrary close together.
*L(a,b,phi)*

All combinations of

, *a*

, and
*b*

, for which *phi*

is
connected, is also called the Julia set of the connected Cauliflower
fractals.
*L(a,b,phi)*

In case

is connected, it can have
area equal to zero, or larger than zero. When the values of
*L(a,b,phi)*

, and *a*

are close to one,
it is very likely that *b*

has an area
larger than zero. Such Cauliflower fractals will be called solid.
For *L(a,b,phi)*

,
*a*^{2}+*b*^{2}<1

cannot be solid.
Algebraic conditions for *L(a,b,phi)*

to be solid
are given below. (It's clear that
a disconnected Cauliflower fractal can not have area larger than zero.)
*L(a,b,phi)*

All combinations of

, *a*

, and
*b*

, for which *phi*

is
connected, is also called the Julia set of the solid Cauliflower
fractals.
*L(a,b,phi)*

The estimated area of the solid
Cauliflower fractals is
`2`

.
**pi**(Area(C_{f}) + Area(C_{g}) - 2**pi**)
/ Area(*C*_{f} **intersection** *C*_{g})

Below characterizations for the two Julia sets of the Cauliflower fractal are presented. Firstly, simple algebraic conditions are given. Secondly, exact conditions are given.

*L(a,b,phi)*

is disconnected or solid are
presented.
*L(a,b,phi)*

is
disconnected.

is disconnected if:
*L(a,b,phi)*

*b* + *a*^{pi/phi} < 1

`(`*ab*^{rho/phi}(1+*a*^{pi/phi}))^{2} <
(1-*b*)^{2}(*a*^{2}-2a**cos**(*phi*)+1)

*rho* = **arccos**(-(1-*a***cos**(*phi*))/**sqrt**(*a*^{2}-2a**cos**(*phi*)+1))

.
*L(a,b,phi)*

is solid.
For

equals *phi*

,
**pi**/2

is solid if:
*L(a,b,phi)*

`2`*a*^{3}*b* > 1

*a*^{6}*b*^{2} - 4(1-*b*) > 0

*a*^{2}*b*^{2} - 4(1-*b*) > 0

For

equals *phi*`2`

where
**pi**/k`k`

is a natural number greater zero,

is solid if:
*L(a,b,phi)*

`(`*a*^{k-1}*b*+2(1-*b*)cos(*phi*))^{2}
- 4(1-*b*) > 0

For

equals *phi*`2`

where
**pi**l/k`l`

, and `k`

are natural number greater zero,
and `gcd(l,k) = 1`

,

is solid if:
*L(a,b,phi)*

`(`*a*^{m-1}*b*+2(1-*b*)cos(*phi*))^{2}
- 4(1-*b*) > 0

`m`

is the smallest *m*

, such
that: `ml = (k - 1) `**mod** k

.
And for the most general condition,

is solid if:
*L(a,b,phi)*

`D = (`*a**b*+2(1-*b*)cos(*phi*))^{2}
- 4(1-*b*) > 0

` `*ab*+2(1-*b*)cos(*phi*)+**sqrt**(D) -
2*a*^{phi/(pi-phi)}(1-*b*)/*b*
> 0

`H`

be the set of all mappings *f, g, ff, fg, gf, gg,
fff,*

and so on.
If there exists `h`_{1}

, and `h`_{2}

element of `H`

, and `p`_{1}

, and
`p`_{2}

element of `{(0,0), (1,0)}`

,
such that *f*(h_{1}(p_{1})) =
*g*(h_{2}(p_{2}))

,
then *L(a,b,phi)*

is connected.
home and email