Welcome to Fractal Forums

Fractal Math, Chaos Theory & Research => (new) Theories & Research => Topic started by: puntopunto on May 31, 2013, 10:23:53 PM



Title: complex not so complex
Post by: puntopunto on May 31, 2013, 10:23:53 PM
PART 1A
(Somehow I am unable to upload larger files, so, sorry, I try it this way)

Already  a year ago I wrote in a post somewhere on this forum:
"You arrived at your formula, taking a complicated route, but it is a very simple and logic formula. No need for complex function theory. This is one example. If I have some time I will show some more."
Now is the time.
This is a simple formula:

        P is the point with coordinates (x,y) and
   f(x,y)=|x|/(x^2+y^2),y/( x^2+y^2) with
   |x|=Abs(x)=
   x if x>=0 and -x if x<0
f maps the left half plane on the right half  and divides both coordinates by the square of the distance from point (x,y) to (0,0). Or saying otherwise it invert the point in the unit circle. So f is a  fold to the right with folding line  the y-axes, followed by the circle inversion in the unit circle.
This is the M-set:

(http://www.stitchstitch.info/forum/post01/1.jpg)

Doesn't look very promising. But look to some results from Julia sets:

(http://www.stitchstitch.info/forum/post01/2.jpg)

(http://www.stitchstitch.info/forum/post01/3.jpg)

The inner square is inside. Augmenting the maximum iterations from 100 to 500 gives this:

(http://www.stitchstitch.info/forum/post01/4.jpg)

The inside of the Julia sets from this and the formulas that follows are very sensitive for the number of iterations. You can find interesting structures by incrementing, but often also by decrementing the max. iterations.
Here is a third one:

(http://www.stitchstitch.info/forum/post01/5.jpg)

This picture is made using the inside "smooth" colouring algorithm. With the standard colouring algorithm you see nothing. With the often used exponential colouring you see just chaos. So choosing colouring algorithms is essential. Other colouring algorithms could give also nice results. For instance:

(http://www.stitchstitch.info/forum/post01/6.jpg)

There are more patterns of this kind to find in this Julia set. They very strongly look like variations of   generalizations of the Koch curve.
By now you might  be curious about other possibilities of this formula. In my member gallery, in the UF part there are about 35 pictures (more to come). All made with this formula or with some logical extensions of it.
I discovered this formula, together with some of the formulas that I will show later,  about 15 years ago, using Fractint.  Here is an translation in Ultra Fractal. Even if you are not interested in the formula, please, read the comments in the formula. They are fundamental for this post.

Code:
fold right {
;by JosHendriks. First in Fractint about 1998. Translated  in Ultrafractal 2012
;
; The formulas act on points, complex number terminology is not used. Although
; complex number and point are completely inter exchangeable, there are advantages
; using points: First fractal creating is essentially geometrically. Second it is
; demystifying, certainly for people without knowledge of complex function theory.
; Thirdly: as soon as you use complex functions you are tempted to do everything
; with z, z^2, exp(z) etc. And not defining maps that acts on the real and imaginary
; parts of the numbers. Moreover the few predefined functions has names that hide
; there geometrical meaning. Flip and complex conjugation are just reflections.
; The cabs function consist of two folds.
;
; The following fractal formula consist of one fold, followed by the
; circle inversion in the unit circle.
; "Folds" maps half the plane on the other half. They are defined by one line.
; That line could be horizontally, vertically or skew. In this formula there is one parameter for the ;position of a vertical line.
;The circle inversion maps
; points inside the circle outside and points outside the circle inside the circle.
; It divides the x- and y-coordinate of a point by the square of the distance of
; that point to the point (0,0).

global:
import "jhe.ulb"

init:
point mandelstart= new point(real(#pixel),imag(#pixel))
; This should be the only line of code, where complex number terminology is visible.
; Necessary because of the default type complex in ultra fractal. We use this point
; for the final addition (translation) in the loop.
;
point p= new point(mandelstart.x,mandelstart.y)
; The point p is a copy of the point mandelstart. It is used in the loop. Results of
; functions (methods) are stored in p. So the final result of each loop is point p.

loop:
 point.fold_r(p,@vertical_line)
: The real  parameter "vertical_line" defines the position of the vertical fold line. Default is 0 ( the line x=0).
 point.circle_inversion(p)
 point.add(p,mandelstart)
; adds the point p to  mandelstart. You can also say translate p over the vector mandelstart.
; The functions fold_r, circle_inversion and add (UF terminology "methods")are
; defined in the class "point"
; You can find them in de file jhe.ulb.
; They acts on the point p. They don't return a value. They change the value of
; the x- and y-coordinate of p (in de formulas represented by p.x and p.y)

 z=p.x+1i*p.y
; This line of code you need for the coloring functions. They expect a complex number
; with the name z. Later I will adept the coloring algoritms. Then this line is no
; longer needed

 bailout:		
point.squarenorm(p)<16
; squarenorm is also defined in the file jhe.ulb. It returns the square of the distance of p to the origin (0,0).

switch:       		
  type = "julia_fold_right"
  seed=#pixel
       		
default:
  title="fold right"
  float param vertical_line
  caption="vertical line x="
  default=0.0
  endparam
}


Thinking geometrically (points, lines, circles, reflections, rotations etc. ) a first extension of the folding along x=0 is to change the position of the fold line. Thus this first formula already has  one parameter. It defines a horizontal fold line x=a.
Here is a comparison of one Julia set which comes from several folding lines:


(http://www.stitchstitch.info/forum/post01/7.jpg)

Top left is a Julia for the fold along x=0. The others are folds along x=a with a between 0 and  -2. All have the same seed.
As you see, it "adds" possibilities.
If you can fold to the right, then you can also fold to the left.  And up and down. But as expected, the collection of the Julia sets are the same. They only are rotated. Finally we can fold skew left and skew right. 
Combining two or more of these folds gives a fascinating scala of possibilities. So I wrote a fairly general formula. Here it is:

Code:
folding_general_1 {
; By Jos Hendriks. First in Fractint about 1998. Translated and extended in Ultrafractal 2012/2013
: See also for comments the formula "right_fold".

global:
import "jhe.ulb"
 ;In this file are the several kinds of folds: left, right, up, down, skew left, skew right, defined.
; For more information see the formula right_fold

init:
point mandelstart= new point(real(#pixel),imag(#pixel))
; the point mandelstart is used for the final translation in the loop
point p= new point(real(#pixel),imag(#pixel))
;p is a copy of mandelstart. It is used in the loop. The final result of the loop is also stored in point p.
if @flag5==1
float phi_r=@angle_r*#pi/180
point q_r=new point(@q1_r,@q2_r)
;there are six parameters named flag. They define if a fold is used or not. 1 means used.
;flag 5 and 6 are for skew folds. They are defined by the parameter phi_r and phi_l, which gives an angle with the positive x-axes and point q_r and q_l on the folding lines
endif
if @flag6==1
float phi_l=@angle_l*#pi/180
point q_l=new point(@q1_l,@q2_l)
endif
loop:
 if    @flag1==1
       point.fold_r(p,@f1)
       endif
       if @flag2==1
       point.fold_l(p,@f2)
       endif
       if @flag3==1
       point.fold_u(p,@f3)
       endif
       if @flag4==1
       point.fold_d(p,@f4)
       endif
;parameters f1,....f4 defines the position of the folding lines.
        if @flag5==1
       point.fold_skew_r(p,q_r,phi_r)
       endif
       if @flag6==1
       point.fold_skew_l(p,q_l,phi_l)
       endif
        point.circle_inversion(p)
;Finally the point p is inverted in the unit circle.
 point.translate(p,mandelstart)
  z=p.x+1i*p.y
; This line of code is necessary for using colouring algorithms.
 
bailout:		
point.squarenorm(p)<16
       		
switch:
                type = "julia_folding_general_1"
                seed=#pixel
                flag2=flag2
                flag1=flag1
                flag3=flag3
                flag4=flag4
                flag5=flag5
                flag6=flag6
                f1=f1
                f2=f2
                f1=f1
                f2=f2
                f3=f3
                f4=f4
                angle_r=angle_r
                q1_r=q1_r
                q2_r=q2_r
                angle_l=angle_l
                q1_l=q1_l
                q2_l=q2_l

default:
  title = "folding_general_1"

  heading
  text="1 for including the specified fold"
  endheading

   int param flag1
    caption = "right fold"
    default=1
    hint="1 for including a fold\
    to the right"
  endparam

   int param flag2
    caption = "left fold"
    default=0
  endparam
  
    int param flag3
    caption = "fold up"
    default=0
  endparam
  
      int param flag4
    caption = "fold down"
    default=0
  endparam
  
      int param flag5
    caption = "fold skew r"
    default=0
  endparam
  
      int param flag6
    caption = "fold skew l"
    default=0
  endparam
 heading
 text="lines for horizontal and vertical folds"
 endheading
  float param f1
    caption = "foldline right "
    default=0
    endparam

  float param f2
    caption = "foldline left "
    default=0
  endparam

  float param f3
    caption = "foldline up "
    default=0
    endparam

  float param f4
    caption = "foldline down "
    default=0
  endparam
 heading
 text="fold skew right"
 endheading
  float param angle_r
caption="angle line r"
default=45.0
endparam
float param q1_r
caption="x point"
default=1.0
endparam
float param q2_r
caption="y point"
default=1.0
endparam
heading
 text="fold skew left"
 endheading
  float param angle_l
caption="angle line r"
default=45.0
endparam
float param q1_l
caption="x point"
default=1.0
endparam
float param q2_l
caption="y point"
default=1.0
endparam
}

The Julia code is as usual.


Title: PART 1B
Post by: puntopunto on May 31, 2013, 10:25:48 PM
POST 1B

Here some typical results. You can see many more in my gallery Ultra Fractal II

Combining left/right fold with an up fold can give Julia's , partly consisting of straight, parallel lines:

(http://www.stitchstitch.info/forum/post01/8.jpg)

(http://www.stitchstitch.info/forum/post01/9.jpg)

Filled and unfilled polygons:


(http://www.stitchstitch.info/forum/post01/10.jpg)

(http://www.stitchstitch.info/forum/post01/11.jpg)

Bifurcations are central:

(http://www.stitchstitch.info/forum/post01/12.jpg)

As many patterns as you wish:

(http://www.stitchstitch.info/forum/post01/13.jpg)

(http://www.stitchstitch.info/forum/post01/14.jpg)

(http://www.stitchstitch.info/forum/post01/15.jpg)

These kind of patterns can change completely just by augmenting the number of iterations by 1.



Title: PART 1C
Post by: puntopunto on May 31, 2013, 10:28:52 PM
PART 1C

You can spend a lifetime finding "tree" variations:


(http://www.stitchstitch.info/forum/post01/16.jpg)

(http://www.stitchstitch.info/forum/post01/17.jpg)

In this complete Julia set you can see ground and figure, both having some meaning. Like in the art of Escher.

All sort of fractals related to the Pascal triangle fractals, the Koch, Minkofski, Sierpinski and other IFS fractals:

(http://www.stitchstitch.info/forum/post01/18.jpg)

(http://www.stitchstitch.info/forum/post01/19.jpg)

(http://www.stitchstitch.info/forum/post01/20.jpg)

(http://www.stitchstitch.info/forum/post01/21.jpg)

You can go wild:

(http://www.stitchstitch.info/forum/post01/22.jpg)

Or create valentine cards:

(http://www.stitchstitch.info/forum/post01/23.jpg)

Below the code of the jhe.ulb file.
There I define a class "point" and several functions acting on those points. My programming experience is not very much. So there might be improvements possible. I would like to have functions that actually returns points. So if somebody has a straightforward solution I would be happy. Anyway, every comment that can improve the code is welcome.
As soon as I am satisfied with the code I will upload the files to the Ultra Fractal  database.
In my next post I will introduce a second large class of fractals with folding.

P.s: the first formula in the thread "a very simple formula", consist of the left fold with folding line x=0 and one "fold up" with folding line y=0, followed by the unit circle inversion. It is not the simplest possibility. Only making one fold, to the right, gives about the same possibilities.  And there is still another simplification possible. About that later.


Code:
 class point {
public:

     func point(float aX, float aY)
     x = aX
     y = aY
     endfunc
     
     static float func norm(point p)
     return sqrt(p.x*p.x+p.y*p.y)
     endfunc


     static float func squarenorm(point p)
     return p.x*p.x+p.y*p.y
     endfunc
     
     static float func distance(point p, point q)
     return sqr((p.x-q.x)*(p.x-q.x)+(p.y-q.y)*(p.y-q.y))
     endfunc
     
     static float func squaredistance(point p, point q)
     return (p.x-q.x)*(p.x-q.x)+(p.y-q.y)*(p.y-q.y)
     endfunc
     
     static func translate(point p, point q)
     p.x=p.x+q.x
     p.y=p.y+q.y
     endfunc
     
     static func add(point p, point q)
     p.x=p.x+q.x
     p.y=p.y+q.y
     endfunc
     
     static func substract(point p, point q)
     p.x=p.x-q.x
     p.y=p.y-q.y
     endfunc
     
     static func square(point p)
     point newp=new point(p.x*p.x-p.y*p.y,2*p.x*p.y)
     p.x=newp.x
     p.y=newp.y
     endfunc
     
     static func multiply(point p, point q)
     point newp=new point(p.x*q.x-p.y*q.y,p.x*q.y+p.y*q.x)
     p.x=newp.x
     p.y=newp.y
     endfunc
     
     static func stretch_circ(point p, float r)
     p.x=r*p.x
     p.y=r*p.y
     endfunc
     
     static func stretch_h(point p, float r)
     p.x=abs(r)*p.x
     endfunc
     
     static func stretch_v(point p, float r)
     p.y=abs(r)*p.y
     endfunc
     
     
     
     static func expo(point p)
     point newp=new point(exp(p.x)*cos(p.x),exp(p.x)*sin(p.y) )
     p.x=newp.x
     p.y=newp.y
     endfunc
     
     static func copy(point p,point q)
     p.x=q.x
     p.y=q.y
     endfunc
     
     
     static func fold_r(point p,float r)
     If p.x<r
     p.x=p.x+2*(r-p.x)
     endif
     endfunc
     
     static func fold_l(point p,float r)
     If p.x>r
     p.x=p.x-2*(p.x-r)
     endif
     endfunc
     
     static func fold_u(point p,float r)
     If p.y<r
     p.y=p.y+2*(r-p.y)
     endif
     endfunc
     
     static func fold_d(point p,float r)
     If p.y>r
     p.y=p.y-2*(p.y-r)
     endif
     endfunc
     
     static func fold_skew_r (point p, const point q, const float phi)
     point.substract(p,q)
     point newp= new point(p.x*cos(2*phi)+p.y*sin(2*phi),p.x*sin(2*phi)-p.y*cos(2*phi))
     If newp.x<p.x
     point.add(p,q)
     else
     point.copy(p,newp)
     point.add(p,q)
     endif
     endfunc
     
     static func fold_skew_l (point p, const point q, const float phi)
     point.substract(p,q)
     point newp= new point(p.x*cos(2*phi)+p.y*sin(2*phi),p.x*sin(2*phi)-p.y*cos(2*phi))
     If newp.x>p.x
     point.add(p,q)
     else
     point.copy(p,newp)
     point.add(p,q)
     endif
     endfunc
     
     static func rotate(point p,const float phi)
     point q=new point(0,0)
     q.x=p.x*cos(phi)-p.y*sin(phi)
     q.y=(p.x)*sin(phi)+p.y*cos(phi)
     copy(p,q)
     endfunc
     
     static func reflect(point p,const float phi)
     point q=new point(0,0)
     q.x=p.x*cos(2*phi)+p.y*sin(2*phi)
     q.y=p.x*sin(2*phi)-(p.y)*cos(2*phi)
     copy(p,q)
     endfunc
       			

          	
     static float func arg(point p)
     if p.x > 0
     float phi = atan(p.y / p.x)
     elseif p.x == 0
            if p.y > 0
            phi = 0.5 * #pi
            else
            phi = -0.5 * #pi
            endif
     else
         if p.y > 0
         phi = #pi + atan(p.y / p.x)
         else
         phi = -#pi + atan(p.y/ p.x)
         endif
     endif
     return phi
     endfunc
		
 	
     
     static func circle_inversion(point p)
     float norm=p.x^2+p.y^2
     p.x=p.x/norm
     p.y=p.y/norm
     endfunc
     
     static func fold_in(point p)
     float norm=p.x^2+p.y^2
     if norm<1
     p.x=p.x/norm
     p.y=p.y/norm
     endif
     endfunc
     
     static func fold_out(point p)
     float norm=p.x^2+p.y^2
     if norm>1
     p.x=p.x/norm
     p.y=p.y/norm
     endif
     endfunc
     
     static func circle_inversion_gen(point p,point mp,float r)
     float norm=(p.x-mp.x)^2+(p.y-mp.y)^2
     p.x=mp.x+(r*r/norm)*(p.x-mp.x)
     p.y=mp.y+(r*r/norm)*(p.y-mp.y)
     endfunc
     
     float x
     float y
}

Title: Re: complex not so complex
Post by: kram1032 on May 31, 2013, 10:40:10 PM
those are some really nice patterns! Great work!

Title: PART 2A
Post by: puntopunto on May 31, 2013, 11:28:44 PM
PART 2A
Here is a second general formula, involving folds. This formula is the same as the formula folding_general_1, except the circle inversion is replaced by squaring.
Squaring a point P(x,y) is defined by f, acting on the coordinates of P and  f(x,y)=(x^2-y^2,2xy).
Geometrically  the point P is rotated by the angle of the line through P and (0,0)  with the X-axes, followed by squaring the distance of the new point by its distance to (0,0).

Code:
folding_general_2 {
;by Jos Hendriks 1998-2013
;for comments see folding_general_1

global:

import "jhe.ulb"

init:

point mandelstart= new point(real(#pixel),imag(#pixel))
point p= new point(real(#pixel),imag(#pixel))
if @flag5==1
float phi_r=@angle_r*#pi/180
point q_r=new point(@q1_r,@q2_r)
endif
if @flag6==1
float phi_l=@angle_l*#pi/180
point q_l=new point(@q1_l,@q2_l)
endif

loop:

 if    @flag1==1
       point.fold_r(p,@f1)
       endif
       if @flag2==1
       point.fold_l(p,@f2)
       endif



       if @flag3==1
       point.fold_u(p,@f3)
       endif
       if @flag4==1
       point.fold_d(p,@f4)
       endif
        if @flag5==1
       point.fold_skew_r(p,q_r,phi_r)
       endif
       if @flag6==1
       point.fold_skew_l(p,q_l,phi_l)
       endif
        point.square(p)
 point.translate(p,mandelstart)
 z=p.x+1i*p.y

  bailout:		
       		point.squarenorm(p)<16
       		
   switch:
                type = "julia_folding_general_2"
                seed=#pixel
                flag2=flag2
                flag1=flag1
                flag3=flag3
                flag4=flag4
                flag5=flag5
                flag6=flag6
                f1=f1
                f2=f2
                f1=f1
                f2=f2
                f3=f3
                f4=f4
                angle_r=angle_r
                q1_r=q1_r
                q2_r=q2_r
                angle_l=angle_l
                q1_l=q1_l
                q2_l=q2_l

default:
  title = "folding_general_2"

  heading
  text="1 for including the specified fold"
  endheading

   int param flag1
    caption = "right fold"
    default=1
    hint="1 for including a fold\
    to the right"
  endparam

   int param flag2
    caption = "left fold"
    default=0
  endparam

    int param flag3
    caption = "fold up"
    default=0
  endparam

      int param flag4
    caption = "fold down"
    default=0
  endparam

      int param flag5
    caption = "fold skew r"
    default=0
  endparam

      int param flag6
    caption = "fold skew l"
    default=0
  endparam
 heading
 text="lines for horizontal and vertical folds"
 endheading
  float param f1
    caption = "foldline right "
    default=0
    endparam

  float param f2
    caption = "foldline left "
    default=0
  endparam

  float param f3
    caption = "foldline up "
    default=0
    endparam

  float param f4
    caption = "foldline down "
    default=0
  endparam
 heading
 text="fold skew right"
 endheading
  float param angle_r
caption="angle line r"
default=45.0
endparam
float param q1_r
caption="x point"
default=1.0
endparam
float param q2_r
caption="y point"
default=1.0
endparam
heading
 text="fold skew left"
 endheading
  float param angle_l
caption="angle line r"
default=45.0
endparam
float param q1_l
caption="x point"
default=1.0
endparam
float param q2_l
caption="y point"
default=1.0
endparam
}

julia_folding_general_2 {
;By Jos Hendriks 1998-2013

global:

import "jhe.ulb"

init:

point juliaseed=new point (real(@seed),imag(@seed))
point p= new point(real(#pixel),imag(#pixel))
if @flag5==1
float phi_r=@angle_r*#pi/180
point q_r=new point(@q1_r,@q2_r)
endif
if @flag6==1
float phi_l=@angle_l*#pi/180
point q_l=new point(@q1_l,@q2_l)
endif

loop:

 if    @flag1==1
       point.fold_r(p,@f1)
       endif
       if @flag2==1
       point.fold_l(p,@f2)
       endif



       if @flag3==1
       point.fold_u(p,@f3)
       endif
       if @flag4==1
       point.fold_d(p,@f4)
       endif
        if @flag5==1
       point.fold_skew_r(p,q_r,phi_r)
       endif
       if @flag6==1
       point.fold_skew_l(p,q_l,phi_l)
       endif
        point.square(p)
 point.translate(p,juliaseed)
z=p.x+1i*p.y


  bailout:		
       		point.squarenorm(p)<16
       		
   switch:
                type = "folding_general_2"
                seed=#pixel
                 flag1=flag1
                flag2=flag2

                flag3=flag3
                flag4=flag4
                flag5=flag5
                flag6=flag6
                f1=f1
                f2=f2
                f1=f1
                f2=f2
                f3=f3
                f4=f4
                angle_r=angle_r
                q1_r=q1_r
                q2_r=q2_r
                angle_l=angle_l
                q1_l=q1_l
                q2_l=q2_l

default:
  title = "julia_folding_general_2"
   complex param seed
   endparam
  heading
  text="1 for including the specified fold"
  endheading

   int param flag1
    caption = "right fold"
    default=1
    hint="1 for including a fold\
    to the right"
  endparam

   int param flag2
    caption = "left fold"
    default=0
  endparam

    int param flag3
    caption = "fold up"
    default=0
  endparam

      int param flag4
    caption = "fold down"
    default=0
  endparam

      int param flag5
    caption = "fold skew r"
    default=0
  endparam

      int param flag6
    caption = "fold skew l"
    default=0
  endparam
 heading
 text="lines for horizontal and vertical folds"
 endheading
  float param f1
    caption = "foldline right "
    default=0
    endparam

  float param f2
    caption = "foldline left "
    default=0
  endparam

  float param f3
    caption = "foldline up "
    default=0
    endparam

  float param f4
    caption = "foldline down "
    default=0
  endparam
 heading
 text="fold skew right"
 endheading
  float param angle_r
caption="angle line r"
default=45.0
endparam
float param q1_r
caption="x point"
default=1.0
endparam
float param q2_r
caption="y point"
default=1.0
endparam
heading
 text="fold skew left"
 endheading
  float param angle_l
caption="angle line r"
default=45.0
endparam
float param q1_l
caption="x point"
default=1.0
endparam
float param q2_l
caption="y point"
default=1.0
endparam
}

Here are the Mandelbrot pictures for  several possible folds:

(http://www.stitchstitch.info/forum/post02/01.jpg)


The first two are right and left fold along the line x=0. The following two are up and down fold along the line y=0
The last two are folds along lines of 45 and -45 degrees through (0.0). All these fractals are good starting points for interesting pictures.
For now I focus on the first, a right fold.  Here some pictures, if you change the position of the folding line:
folding line x=.5:
(http://www.stitchstitch.info/forum/post02/02.jpg)
folding line x=1:

(http://www.stitchstitch.info/forum/post02/03.jpg)
folding line x=2:

 (http://www.stitchstitch.info/forum/post02/04.jpg)

folding line x=3:

 (http://www.stitchstitch.info/forum/post02/05.jpg)
 

Changing the folding line introduce the tricorn and brings in the Mandelbrot set for z^2 . If the line is far enough to the right there is just that fractal alone.
All the fractals from above seem to have interesting zoom possibilities. I started a category Ultra Fractal II in mygallery. Please have a look there to see some of the possibilities
Also interesting is the presence of mini tricorns together with minibrots in several of these fractals:

(http://www.stitchstitch.info/forum/post02/06.jpg)

While zooming it is often a surprise if you are ending with a (deformed) minibrot or ending with a (deformed) minitricorn.
Anyway I would be glad if one of the zooming experts would give some of the above fractals a try. I am really curious about possible results.


Title: PART 2B
Post by: puntopunto on May 31, 2013, 11:30:13 PM
PART 2B
Here an interesting comparison  of Julia's with the same seed for the fractals with a left fold and different folding line:
(http://www.stitchstitch.info/forum/post02/07.jpg)



Above left, is the Juliaset for z^2. To the right for the same seed the Juliaset for a  left fold along x=.5. The following pictures are the  sets for folds x=1, x=2, x=3. The Julia sets changes and splits into two equal parts that seems to be copies of the Juliaset for z^2. The last picture is made from a fold with x=0.


Below a picture of a part of the Juliaset with the fold x=.5 and the exponential coloring algorithm:
(http://www.stitchstitch.info/forum/post02/08.jpg)



This clearly shows that a fold is involved.

Then combining two  folds. Below a few of the many possibilities:

(http://www.stitchstitch.info/forum/post02/09.jpg)



Below are several Julias from the same, randomly taken, seed, but with more then one fold involved:
(http://www.stitchstitch.info/forum/post02/10.jpg)


The first is the Julia set derived from the standard Mandelbrot set. The second has all fold along the two axes, and one skew 45 degree fold. The other six has 2 or 3 or 4 folds out of the set of the second one. There are more possibilities. And with changing the position of fold lines infinitely many.
They can resemble Julia's from the standard Mandelbrot set, but there also many very different ones.  Moreover sometimes other coloring algorithms then the standard one can reveal interesting structures.

Here is, I think, an amazing one:
(http://www.stitchstitch.info/forum/post02/11.jpg)


The border reminds me of an old tree trunk. The inside a Escher like filing with trees.

Title: POST 2C
Post by: puntopunto on May 31, 2013, 11:30:39 PM
POST 2C
And here a small collection of other Julia's:

(http://www.stitchstitch.info/forum/post02/12.jpg)
(http://www.stitchstitch.info/forum/post02/13.jpg)
(http://www.stitchstitch.info/forum/post02/14.jpg)
(http://www.stitchstitch.info/forum/post02/15.jpg)
(http://www.stitchstitch.info/forum/post02/16.jpg)
(http://www.stitchstitch.info/forum/post02/17.jpg)

And this look like  a funny representation of the Mandelbrot set. But it actually is inside a Julia set:

(http://www.stitchstitch.info/forum/post02/18.jpg)
It is made with the smooth coloring algorithm. You only have to change the maximum iterations by one to get another one:

(http://www.stitchstitch.info/forum/post02/19.jpg)

Enough for now. I have more to say and to show. That I will do in some shorter posts. There is a final aim: To show that the fundamental transformations for fractal creation are fold and stretch. If correct, I believe that is revolutionary.
If you are going to use my formulas, please don't upload them to the database of Fractint. I will do that as soon as I am satisfied with the formulation and the comments. Any idea will be welcomed.

Title: Re: complex not so complex
Post by: Levi on June 01, 2013, 03:40:37 AM
Wow! Nice stuff. Some of those Julias are just gorgeous.

Was surprised to see folded Mandelbrots that looked like rotated slices of the Mandelbulb...

And the appearance of shapes similar to the 'mobiusbrot': http://www.fractalforums.com/mandelbrot-and-julia-set/m-set-on-a-partialtotal-mobius-cylinder-looks-neat/
Although the idea behind mobiusbrot is almost identical to this, so I guess that shouldn't be surprising.

Good work puntopunto!!

Title: Re: complex not so complex
Post by: Kali on June 01, 2013, 03:58:47 AM
It's nice that you found all this by yourself. Now you would like to take a look at this thread:

http://www.fractalforums.com/new-theories-and-research/very-simple-formula-for-fractal-patterns/

And also it's nice how you found the same fractal I made some time ago:

(http://nocache-nocookies.digitalgott.com/gallery/7/3869_09_05_11_3_38_05.jpeg)
http://www.fractalforums.com/index.php?action=gallery;sa=view;id=7153

Good work :)

Title: Re: complex not so complex
Post by: M Benesi on June 01, 2013, 06:22:02 AM
  @Kali - hehe, I thought of you when I saw the first tree in the thread.


  Very nice images. 

Title: Re: complex not so complex
Post by: puntopunto on June 01, 2013, 08:46:38 AM
Quote from: Kali on June 01, 2013, 03:58:47 AM
It's nice that you found all this by yourself. Now you would like to take a look at this thread:

http://www.fractalforums.com/new-theories-and-research/very-simple-formula-for-fractal-patterns/

And also it's nice how you found the same fractal I made some time ago:


Did you actually read my post?

Quote from: puntopunto on May 31, 2013, 10:23:53 PM
P.s: the first formula in the thread "a very simple formula", consist of the left fold with folding line x=0 and one "fold up" with folding line y=0, followed by the unit circle inversion. It is not the simplest possibility. Only making one fold, to the right, gives about the same possibilities.  And there is still another simplification possible. About that later.


That fractal I know already for a long time. I made it with Fractint about 15 years ago.

Also some other formulas mentioned in the topic "very simple formula..." are part of my formula general_fold_1, but that formula is far more general, by changing the positions of the folding lines and introducing skew folds.
My posts are really about a new geometric foundation of fractal generation. Although still working on it I think I can show that a very, very large class of fractals can be made using only folds and stretches. For instance, as I will show later, you can create the Mandelbrot set in that way.
 
I avoid also complex notations with "i" and "z". I don't use complex function theory. There are very good reasons doing so:

1. Fractal creating is essentially geometrically. Thinking in "folds" you will get faster the idea of changing the folding line then thinking abs(z).

2 .Second it is demystifying, certainly for people without knowledge of complex function theory. By the way, many books introducing complex numbers and all the videos, I saw on youtube doing so, don't do that correctly.

3. As soon as you use complex functions you are tempted to do everything
with z, z^2, exp(z) etc. And not defining maps that acts on the real and imaginary
parts of the numbers. Moreover the few predefined functions has names that hide
there geometrical meaning. Flip and complex conjugation are just reflections.







Title: Re: complex not so complex
Post by: Kali on June 01, 2013, 02:22:52 PM
Quote from: puntopunto on June 01, 2013, 08:46:38 AM
Did you actually read my post?

Actually, no. I only read it entirely now, yesterday I took a quick look at the images and formulas cause I didn't have the time to read all at that moment. But I saw that most of the patterns and formulas are related to the ones I discovered myself, based on works by Tom Lowe (mandelbox formula) and Sam Monnier (ducks formula), including the patterns on folded mandelbrot (also when I discovered the patterns inside the "burning ship", I searched exhaustively in the web to see if somebody knew about this and I found nothing.). Just wanted to let you know that I've found similar stuff, and...

Quote
That fractal I know already for a long time. I made it with Fractint about 15 years ago.

...that's ok, congrats, I just didn't know of it, did you publish anything before?

Quote
P.s: the first formula in the thread "a very simple formula", consist of the left fold with folding line x=0 and one "fold up" with folding line y=0, followed by the unit circle inversion. It is not the simplest possibility. Only making one fold, to the right, gives about the same possibilities.  And there is still another simplification possible. About that later.
Also some other formulas mentioned in the topic "very simple formula..." are part of my formula general_fold_1, but that formula is far more general, by changing the positions of the folding lines and introducing skew folds.

Yes, I know there is also a 1 fold version, as you can see in my entangled tree image similar to yours. Also I've been exploring a lot of combinations of foldings, symmetries, rotations, hybrids, including the 3D version of this kind of fractals, and I've been posting some of my findings in other topics here in FF.

Quote
My posts are really about a new geometric foundation of fractal generation. Although still working on it I think I can show that a very, very large class of fractals can be made using only folds and stretches. For instance, as I will show later, you can create the Mandelbrot set in that way.
I avoid also complex notations with "i" and "z". I don't use complex function theory.


I'm pretty sure you can't create the Mandelbrot set using ONLY folds and stretches (no rotations, no complex multiplications), but now I'm curious because if you really can do it, then it's extendable to 3D...

So maybe you have found the holy grail 15 years ago and you don't know it :)


Title: Re: complex not so complex
Post by: M Benesi on June 01, 2013, 10:09:20 PM
Quote from: Kali on June 01, 2013, 02:22:52 PM
I'm pretty sure you can't create the Mandelbrot set using ONLY folds and stretches (no rotations, no complex multiplications), but now I'm curious because if you really can do it, then it's extendable to 3D...

 I'm wondering what you'd get if you folded over the angle between the original and double angle....

   z^2 Mandelbrot = r^2 [ cos(2*theta) + sin (2*theta) ]

2* theta = doubled angle
1.5 theta= angle of line to fold over
theta = original angle ====  atan2(y,x)

  though the easiest way to do this is to

a)  rotate x and y -1.5 * theta so that they fold over the x axis
b) fold them over the x axis
.... x=x
.... y=-y
c) rotate them (x,y)  1.5 * theta  (back to original)
d) you probably need to go ahead and multiply them by their magnitude ???

which technically involves a rotation......

Title: Re: complex not so complex
Post by: kram1032 on June 01, 2013, 11:29:25 PM
I thought, fold and stretch are well known as being fundamental parts of fractal imagery?
More generally, you need some form of deform (which might be fold) and rescale (which might be stretch) to give rise to a fractal pattern. Any transformation that does any of this will give rise to fractal patterns for at least a fraction of the involved parameter sets.

Either way, those are really gorgeous works!
It's amazing how the very same basic patterns (like, say, that tree structure) can appear like that over and over and yet produce so very different images. The ultimate puzzle generator.

Title: Re: complex not so complex
Post by: Dinkydau on June 01, 2013, 11:36:58 PM
Great work

Title: PART 3
Post by: puntopunto on June 02, 2013, 12:05:09 AM
note for Kali:
Thanks for your gentle reaction. I will answer later and show you the Mandelbrot construction. But after I have make very clear what I mean by folding and stretching. I must also disappoint you. It is no step further to the holy grail. In my opinion it is almost certain there is no equivalent of the Mandelbrot set in 3D. But, well, that's also something a holy grail should do, shouldn't it?

PART 3

First I want to unify the idea of a line fold and circle inversion. The circle inversion is often called reflection in a circle. That's because reflection in a line and inversion in a circle shares important properties. For instance:
A circle that intersect the inversion circle perpendicularly, is invariant (does not change) under the circle inversion and a line perpendicularly to the reflection line is also invariant. 
Both transformations shares the property that if the image of point a is b then the image of b is a.
Etc.

Moreover we can extend the real plane with ONE point, called infinity (see for a model of that plane wikipedia, Riemann sphere) . Then for a circle inversion the image of the centre of the inversion circle  is that point infinity. So the inversion is defined for every point. The point infinity lies on all lines. Going along a line in both directions you are going to that same point infinity. So you can think of that line as a (infinity large) circle. On the extended plane circles and lines plays the same role.
 
A reflection in a line consist just of two fold, one to the left and one to the right. I have to be very careful here. Up until now I was thinking about folds as executing them one after another. Reflection is more as doing two folds at the same time. It is better to think point by point if we describe  the relationship between folds and reflection.
As an example, reflecton  in the Y-axes (x=0) is the same as:
      for every point P(x,y)
      If x<0 then fold to the right and
      if x>0 then fold to the left
We can do the same thing with the reflection (inversion) in a circle:

I define fold_in as
      
      if P(x,y) lies outside the circle apply the circle inversion

And

fold_out as

      if P lies inside the circle apply the circle inversion

And now we can say:

Circle reflection (inversion) is the same as
      for every point P(x,y)
      if P lies in the circle fold_out
      if P lies outside the circle fold_in

With these reasonable definitions for folds we have a fairly  complete set: fold left and right, fold up and down, fold skew left and skew right, fold in and out.

All the fractals you can create with folding_general_1 are created with folds and nothing else.

Now we have access to fold_in and fold_out we can made a really very simple formula, capable to generate fractal images, namely:

fold_left followed by fold_out

Here some results:
(http://www.stitchstitch.info/forum/post03/2.jpg)

(http://www.stitchstitch.info/forum/post03/1.jpg)

(http://www.stitchstitch.info/forum/post03/3.jpg)

The first two has folding line x=0. The last x=-.5

Title: Re: complex not so complex
Post by: Roquen on June 02, 2013, 01:05:13 AM
puntopunto: Isn't the real problem "how" complex numbers are presented?  The algebra itself is very straight forward and accessible to far wider audience than domain and conformal mappings.  And more importantly it makes forward and inverse trig functions drop like flies and the properties of affine transforms likewise show up by algebraic manipulation.  The bottom line is that if you really want to understand geometry you can't just be given a small set of black-boxes.

As an example in your last post you describe building a reflection out of a fold and conditionals.  Now you could go forward and build all of the affine transforms out of reflection...but there's no algebra structure to manipulate and I doesn't really seem any easier to understand.

Title: Re: complex not so complex
Post by: Ryan D on June 02, 2013, 07:28:38 AM
Quote from: puntopunto on June 01, 2013, 08:46:38 AM
That fractal I know already for a long time. I made it with Fractint about 15 years ago.

As an aside, I would be happy to see some of your old Fractint formulas / parameters posted somewhere.  (I'm a dinosaur, I still have more fun with Fractint than anything else.)  The only work of yours I have been able to find in the past is from the Fractint mailing list from 2002 and 2003.  Some of the images shown on your first fractalforums post are very interesting to me.

http://www.fractalforums.com/mandelbulb-3d/first-post-something-fundamental-about-fractal-generation-t11008/

Ryan

Title: Re: complex not so complex
Post by: s31415 on June 02, 2013, 11:07:12 AM
Hi,

Picturing the complex plane plus a point at infinity is indeed a good way to construct the most general formula of this type. You then have generalized foldings identifying the disks on each side of a circle on the sphere. For instance the fold along a straight line going through the origin is associated to a great circle going through the point at infinity. The circle inversion fold associated with the unit circle is a fold along the equator of the sphere, if you pictured it with the point at infinity at the a pole. More generally, you can pick just any of these folds, and compose it with a Moebius transformation. In this way you can obtain a fold along any circle.

More generally, this type of fractals are obtained by iterating a "quasi-conformal" map of the sphere. By "quasi-conformal map", I mean a map which is conformal except possibly on a subset of measure zero. For instance the fold is conformal everywhere, except on the circle you are mirroring about. You can obtain more general conformal maps by composing the folds with more general conformal maps of the sphere, like for instant rational or holomorphic functions.

This is a huge class of maps. There will probably still be many people who will for some reason pick a random family of maps in this class, get similar patterns and claim a discovery. A more interesting task would be to identify in this class of maps the ones which are in some aspects special.

For instance the fact that the Ducks formula is obtained by composing a fold with the logarithm function:
http://algorithmic-worlds.net/blog/blog.php?Post=20110227
implies some rather unusual properties for the associated fractal patterns:
http://algorithmic-worlds.net/blog/blog.php?Post=20110724

Also, you cannot get the Mandelbrot set from folding transformations as they are defined above. The Mandelbrot set is obtained by iterating a conformal map, while the folds are necessarily non-conformal at the fold. And indeed, there is no Mandelbrot set in 3d because there is no 2-1 global conformal transformation of the 3-sphere or R^3 to themselves. People like to ignore this fact to preserve the hope...

Sam



Title: Re: complex not so complex
Post by: kram1032 on June 02, 2013, 11:20:31 AM
With a point at infinity, you turn your space into a projective one. In such a space, n-spheres and n-planes are equivalent to each other and all translations in non-projective space can be represented by rotations of the projective space.
Now, each rotation geometrically is equal to two reflections. So if you allow any reflection along a projective plane or sphere in projective space, you get any combination of translations, rotations and reflections in non-projective space.

This, as has been shown before, has the potential to cover the entire space with nice fractal patterns. All you need to add to that is some kind of scaling.

Title: Re: complex not so complex
Post by: Kali on June 02, 2013, 04:17:11 PM
Code:
This is a huge class of maps. There will probably still be many people who will for some reason pick a random family of maps in this class, get similar patterns and claim a discovery.

I hope that wasn't for me  :embarrass:

Anyway I gave you the proper credits and I've said that I took the basic idea of your ducks formula, and your explanations about how this patterns are created. Maybe I claimed a discovery because it's so mathematical simple, computational cheap, and also extendable to 3D.

Btw, if you can run webgl, take a look at this:

https://www.shadertoy.com/view/MssGD8

I didn't see any other 3D formula capable of this results using so little code, so, don't you think that I can claim somehow a discovery?



Title: Re: complex not so complex
Post by: s31415 on June 02, 2013, 07:12:58 PM
@Kali: No, but this was a silly comment, sorry about that.

Sam

Title: Re: complex not so complex
Post by: puntopunto on June 04, 2013, 11:38:52 AM
It looks like that there is some misunderstanding about my  intentions. My intentions lies in the title of this topic: complex not so complex. I mean that as in "complexity" as well as complex in the mathematical term "complex". I am trying to reformulate basic fractal generation in such a way that you have a small collection of transformations, geometrically easy to grasp, but capable of creating many fractals.
My drive is "didactically". So even name giving is important to me. That's why I talked about the Riemann sphere. I tried to explain why fold_in and fold_out are logic names. It appears to me that the folds as defined earlier together with stretches, which I will define later in an obvious way, is such a collection.
You can, then, loosely spoken, talk like "take a point, make a fold, where does your point land, now push or pull a little in some direction, the point will have gone again to another place. Now do this operation over and over again until it lands in a forbidden part. If it hasn't land in that part after let's say a hundred times, you stop as well. Do this for all points. You will have a number for all points and you can color the point according to that number". Many people will  understand that.
Also a piece of code like
fold_left (p,...}
fold_down(p, ...)
stretch(p, ...)
is  then easy to understand.

For the record, I didn't say nowhere in my posts that I could construct the Mandelbrot set with folds. I said I could construct it with folds and stretches. I think sam among others, posting on this topic, are aware of this. Here is the construction:

Loop for point P:
With folding line the X-axes:
   if the point lies under it fold_up, If not fold_down.
With folding line the line through  P, with an angle with the X-axes that is half the angle of the line through O and P and the X-axes :
   if the point is to the left fold_right
   if the point is to the right fold_left
stretch_circular ( even without defining it, this will be clear) with factor length OP.

The construction is not unique. Every two lines through O and with  angle 1/2 phi, phi being the angle (OP,X-axes) will do.
(this serves also as an answer to Kali)

I don't know if I should use this in an explanation. Rotate and scale looks simpler. But there are some advantages: You can stay in the same terminology and in the calculations you need no more then to know how to decide on with side of a line a point lies, how to calculate the image of a folded point, definition of tan.
The main aim is to have a good collection of simple formulas to construct fractals. With that you can go to point multiplication, and together with point addition showing commutativity, associativity  etc. justifying the name multiplication. And you have the fractals to show their usefulness.

It looks to me as a good way to introduce complex numbers. And you have the basic concepts, with their geometrical meaning without even mention the words complex or imaginair. After all the number one is as real (meaning existing in the real world) as i. They both, like every mathematical object, are constructions of our minds.  That the number one feels very real is because we have so many useful representations for it.

I, myself, are not so happy with the usual introduction of complex numbers. Why?
Mostly they start with something like:

We introduce a totally new number, with the name i and i=square root of -1

or

We introduce a new number, not one of the reals and for that new number, represented by the symbol i. we have i^2=-1

Take the first one.
They have told you over and over again that the square root of a negative number don't exist, that it is not defined. So here they define something, named i. to be the same as something that don't exist.
That make no sense to me. Moreover even after i has been defined properly, and with that the square root of -1 has been given meaning, even then, the expression is somewhat obscure. Indeed, except zero, all complex numbers has two square roots, so the square root of -1 is not only  i but also -i.

In the second one, the -1 is oke, but what is the 2? Short for ixi? Multiplication? I don't know a multiplication for i

After that, if you are good in manipulating expressions with reals. working with complex expressions is easy. All is the same, the i acts in the same way as the a,b and c's. It's easy to learn the tricks. Only if you encounter i^2 you replace it by -1. But what is the meaning, what is the use. You don't have a representation that gives meaning to what you are doing.

Back to the folds. I started to extend the formulas I already had. For me the transitions of Julia sets, by changing positions of folding lines to two copies or more was new, also the M sets combining folds and changing the fold line position with multiplication ( apart from the burning ship fractal). That they are new to me does not say very much. Between 2003 and 2011 I never looked at fractals or gave it a thought. But I looked a bit around, finding some interesting  developments involving folds, like the log(laps(z)) formula on the site of Samuel and the examples in the topic "A very simple formula". But that was not exactly the same thing I did. So I put it in a topic. To find out if it is interesting, if it was done before and if people has ideas about another way of introducing fractals or ideas of improvement of my code.
By analogy  (left-right, up-down) I tried in-out. And I was particularly pleased with that last formula in my last post. So simple, so easy to understand.

Quote from: Roquen on June 02, 2013, 01:05:13 AM
Isn't the real problem "how" complex numbers are presented? 
Certainly it is also about representations

Quote from: Roquen on June 02, 2013, 01:05:13 AM
As an example in your last post you describe building a reflection out of a fold and conditionals.  Now you could go forward and build all of the affine transforms out of reflection...but there's no algebra structure to manipulate and I doesn't really seem any easier to understand.

Yes I think you can define multiplication and addition by folds. And no, as far as I can see, that does not look very useful. But from folds to rotations and squaring is a short step and then you have a meaningful opportunity to show (0,1)^2=(-1,0) and square root (-1,0)=(0,1) or (0,-1). Somewhere in the process there is a moment to step over, introduce i as (0,1) for short and a as (a,0) for short. Then it is obvious that i^2=-1 etc.

Quote from: kram1032 on June 01, 2013, 11:29:25 PM
I thought, fold and stretch are well known as being fundamental parts of fractal imagery?

Very true. I liked the example of kneading dough in a book of Peitgen ea.

Quote from: Kali on June 01, 2013, 02:22:52 PM

.....did you publish anything before?

Yes, I know there is also a 1 fold version, as you can see in my entangled tree image similar to yours. Also I've been exploring a lot of combinations of foldings, symmetries, rotations, hybrids, including the 3D version of this kind of fractals, and I've been posting some of my findings in other topics here in FF.
 

No, not on fractals.

To be very clear: I don't claim anything. I am not interested in it. If I do, accidentilly, something special, people will give me credits. And I will look to those other topics and your findings.

Quote from: s31415 on June 02, 2013, 11:07:12 AM
And indeed, there is no Mandelbrot set in 3d because there is no 2-1 global conformal transformation of the 3-sphere or R^3 to themselves. People like to ignore this fact to preserve the hope...

But do those people understand the fact. Is there an argument, without using advanced math? And 2-1 is 1-1?

Quote from: Ryan D on June 02, 2013, 07:28:38 AM
As an aside, I would be happy to see some of your old Fractint formulas / parameters posted somewhere. 

Sorry, I don't have them any more. But it couldn't be that difficult to translate the formulas in this post. I think you have to restrict the number of parameters.

Below some zooms into the same area of the M-set using the formula folding_general_2 with two skew folds. I use the absolutely fantastic coloring function Mandelbrot Multiwave Coloring from Pauldebrot. Although I don't understand how to use the parameters, it's awesome. Thanks for that.

(http://www.stitchstitch.info/forum/post04/1.jpg)

(http://www.stitchstitch.info/forum/post04/2.jpg)

(http://www.stitchstitch.info/forum/post04/3.jpg)








Title: Re: complex not so complex
Post by: kram1032 on June 04, 2013, 02:10:57 PM
I feel like the mistake about introducing i isn't so much how the introduction is phrased but rather how before that, the existence of such a thing is denied.
Just don't tell the kids that there is no square root of -1 if they are wondering about it, but rather tell them, that this will be covered later on but at the same time encourage them to try it for themselves. Just give a hint, that they should name the corresponding number as an unknown for now and see what they can discover from there by themselves.

One of the biggest mistakes in almost all education seems to be, that it's all geared against self-exploration. You'd just need some semi-mysterious nudges to pique a kid's curiosity and if you give the opportunities, they might explore and discover things on their own.
But raising ahead is highly discouraged in most official teaching/learning environments.

Anyway, rant over.
Giving a more geometrically inspired introduction to it all would also help. Though, if you try to not use i, you will be able to do the same things but in way less elegant ways. "i" is essentially a construct that simplifies a ton of things, even if the initial construction doesn't do it justice and even is based on a contradiction of previously learned.

Title: Re: complex not so complex
Post by: Roquen on June 04, 2013, 05:53:56 PM
@kram1032:  Ah but sqrt(-1) is always non-sense under the rules of the game called the algebra of reals.  If you want to give it meaning, you have to make up a new game with new rules.

@puntopunto: First off, I'm not attempting to discourage you in any manner w/r to your write-up.  Nor am I attempting to discourage anyone from taking what they can from it.  However from the contents of your last post you're discussing complex numbers from a history standpoint, which ignores modern algebra.  For example: 'i' is not a number.  It can't be.  If it were the algebra doesn't work (SEE: complex number paradox).  Likewise none of the offspring would work.  Dual numbers: i2=0 -> i=0 therefore it collapses to Reals.  Split-complex: i2=1 -> i=+/-1.  The second component always has a concrete value, so this doesn't work either.  Quaternions: i2=j2=k2=ijk=-1, collapses to complex.  None of these are numbers...they symbols used to denote the basis set of the vector space.  It certainly is a problem that most introductions are based on this broken historic notion.  The second problem with complex number is that vectors replaced them for working geometric problem of the type under discussion, so there are few reference that discuss them.  And lastly, you look at complex differently for geometric problems than you do for analysis of real valued functions.  For example, for geometry you virtually always are only interested in the principle power.

Title: Re: complex not so complex
Post by: s31415 on June 04, 2013, 08:41:01 PM
Quote from: puntopunto on June 04, 2013, 11:38:52 AM

But do those people understand the fact. Is there an argument, without using advanced math? And 2-1 is 1-1?


The argument goes as follows. We presumably want two properties for a hypothetic "3d M-set":
1) It should be self-similar.
2) The small scale details can be deformed, but should be recognizable.
In all the fractals based on the iteration of a map, self-similarity occurs because we are iterating a many to 1 map (i.e. a map such that each point in the image has several preimages). This crucial property imply that the orbits merge at each iteration. When two distinct regions are mapped onto one, then the fractal pattern they will ultimately contain will be related, because all the subsequent iterations will be the same. This is how fractal structures and self-similarity occur. This means that property 1) imply that we need a many to 1 map, and in particular a 2 to 1 map if we want to stay as close as possible to the original Mandelbrot set.
Property 2) requires the map to be conformal. Conformal maps deform patterns, but preserve angles, which implies that they approximately preserve shapes locally. If we use a non-conformal map, the small scale pattern will get irremediably stretched, as is familiar from the Mandelbulb or the quaternionic M-set, for instance.

Now it can be shown that in dimension 3 or higher, the only conformal maps of the sphere to itself are 1 to 1. This is shown by analysing infinitesimally what it means for a map to be conformal, and one deduce that in dimension 3 or higher, the only conformal maps are the translations, the rotations, the dilatations and the special conformal transformations. The proof can for instance be found in Chapter 4 of
http://books.google.ch/books?id=keUrdME5rhIC&printsec=frontcover&hl=fr#v=onepage&q&f=false
but there might be better references.

One way of going around this obstacle is to slightly relax the condition of conformality, and allow maps which are "quasi-conformal" in the sense that they are conformal everywhere except on a subspace, like the folds. This is how the Kaleidoscopic IFS fractals are generated. These are the fractals that are closest to satisfying the conditions above, and imho they are also the best looking 3d fractals.

Sam

Title: Re: complex not so complex
Post by: Syntopia on June 04, 2013, 09:47:37 PM
Quote from: s31415 on June 04, 2013, 08:41:01 PM
1) imply that we need a many to 1 map, and in particular a 2 to 1 map if we want to stay as close as possible to the original Mandelbrot set.

I'm not sure I follow why the map should be 2-1 when generalizing to three dimensions. For instance, a 2D fractal using the component-wise abs(...) operator for folding on the x and y axis, is a 4-1 mapping. In 3D dimensions it generalizes to a 8-1 mapping (folding in the xy,yz,xz planes). Of course this doesn't help much when there is only 1-1 conformal mappings.

Title: Re: complex not so complex
Post by: s31415 on June 04, 2013, 09:53:22 PM
Quote from: Syntopia on June 04, 2013, 09:47:37 PM
I'm not sure I follow why the map should be 2-1 when generalizing to three dimensions. For instance, a 2D fractal using the component-wise abs(...) operator for folding on the x and y axis, is a 4-1 mapping. In 3D dimensions it generalizes to a 8-1 mapping (folding in the xy,yz,xz planes). Of course this doesn't help much when there is only 1-1 conformal mappings.
True, I have no good reason to ask for a 2-1 map, except for the fact that the 2d M-set uses a 2-1 map.

Title: Re: complex not so complex
Post by: kram1032 on June 04, 2013, 10:03:24 PM
Roquen: I suppose so. But then I guess, what should be said to kids is, that the corresponding number does not exist in what we call the Real Numbers (with the rest of the explanation basically unchanged)

Title: Re: complex not so complex
Post by: M Benesi on June 05, 2013, 02:28:48 AM
Quote from: s31415 on June 04, 2013, 08:41:01 PM
The argument goes as follows. We presumably want two properties for a hypothetic "3d M-set":
1) It should be self-similar.
2) The small scale details can be deformed, but should be recognizable.

hehehe.  Found that a long time ago. 

(https://lh4.googleusercontent.com/7SnraN1o23rEDkgklewQXn5u_fSB0-zc37sr1lA7KMw=w480-h360-no)

Title: Re: complex not so complex
Post by: jehovajah on June 05, 2013, 06:26:11 AM
Very nice work puntopunto!

Analogous thinking has been an essential part of human proportioning since records were kept. Of course, your approach will be unfamiliar to some, but may be a godsend to others.

Just remember it is Analogous and hopefully will be more intuitive, less arcane in terminology.
Carry forward the principles of the Erlangen Programme and make Klein proud!

Title: Re: complex not so complex
Post by: s31415 on June 05, 2013, 10:18:23 AM
Quote from: M Benesi on June 05, 2013, 02:28:48 AM
hehehe.  Found that a long time ago. 

(https://lh4.googleusercontent.com/7SnraN1o23rEDkgklewQXn5u_fSB0-zc37sr1lA7KMw=w480-h360-no)

This is a good example of what happpens when using a non-conformal map. The small scale patterns are stretched and unrecognizable.

Title: Re: complex not so complex
Post by: kram1032 on June 05, 2013, 11:25:44 AM
I wonder if there would be a way to have the small scale patterns stretch in ways that don't cause whipped cream (infinite stretch) or perfectly recognizable patterns (as happens in the MSet where, if you zoom in further and further on a certain point, it will just become a more and more defined shape, looking more and more like the Julia set corresponding to that point), but rather where the smaller scale structures are visually different, yet still full of details.
That, then, wouldn't be a fractal in one of the stricter senses of repeating (almost) the same thing over and over but the component of indefinite amounts of details would still happen.

Title: Re: complex not so complex
Post by: puntopunto on June 05, 2013, 12:31:34 PM
Quote from: kram1032 on June 04, 2013, 02:10:57 PM

 "i" is essentially a construct that simplifies a ton of things, even if the initial construction doesn't do it justice and even is based on a contradiction of previously learned.

You're sure?
Take the ordered pair of real numbers. Use points with there coordinates and/or the 2D vectors as representation. Define addition, multiplication and the scalar multiplication on the ordered pairs. Justify it by parallelogram construction and rotation. Show (0,1)^2=(-1,0). From there you can have expression as p^2+(2,3)p+(0,1)=0 and |p-(0,1)|=0 (thinking in points) or the same with a v(thinking in vectors) or with z for compatibility  with the most used notation.
Let's do a calculation as an example (a+(0,1)b)2 (a,b complex, points, vectors) =a2+2(0,1)b+((0,1)b)2=a2+2(0,1)b+(0,1)2b2))=a2+(0,2)b+(-1,0)b2=a2+(0,2)b-(1,0)b2. Try it for yourself, there is not so much difference with the i notation. In the beginning there is some struggle, as always if you change a notation system.

About that, there is a superb chapter in Escher, Gödel, Bach. There, Hofstadter introduce a collection of objects, I think he names it an alphabet and defines a few relations on it with unusual names and symbols. Then he ask you to do some calculations. I did, found it not really easy and made several mistakes. After that he shows that what I had done was essentially the same as adding and subtracting natural numbers. I found it superb because I absolutely did not have the idea I was doing so.

Take a page with some complex function theory. How much "i" is there? After introduction it's all  about log(z), exp(z), z2 etc. And that won't alter if you consequently use (0,1) and not i.
You certainly can avoid i without much harm. But I am not promoting that. For continuity you have to use i. Practically everything that has been written uses it.

The introduction of i with i=square root (-1) is not so much based on a contradiction. It is a problem of order. It should be the principal square root of (0,1) is (-1,0). We abbreviate (0,1) to i and (-1,0) to -1. Then the square root of -1 still doesn't exist on the reals, but it does on the complex numbers.

@Sam
Explanation very clear. Thanks.

Title: Re: complex not so complex
Post by: puntopunto on June 05, 2013, 01:12:37 PM
This picture is a bit strange to me. I expect near the "border" where the white/grey parts are to enter the Julia set. To me it looks like the iteration process is changing. The small blue points are obvious in. Can somebody tell  what is happening?
(julia_general_folding with one up_fold)

(http://www.stitchstitch.info/forum/post06/1.jpg)

Title: Re: complex not so complex
Post by: puntopunto on June 05, 2013, 03:47:41 PM
Oeps! I was going through the zooms of Pauldebrot and noticed that (approximately) many fold symmetries suddenly changes in 4, 6, 8 fold symmetries.

Title: Re: complex not so complex
Post by: kram1032 on June 05, 2013, 05:07:33 PM
Puntopunto, "normal" vector algebra doesn't even have a vector product defined. I mean, there are the scalar and the cross products, but the former gives you a scalar and the later only works in 3D.
If you define all those extra things, you essentially already do complex numbers. Whether you take two orthonormal unit vectors x,y or a real and imaginary direction really doesn't change anything anymore. You're using clifford algebra while forcing the notation of normal vector algebra onto it.

When I said, you can do the same things with vector algebra, I meant without a concept of multiplying vectors together. You'll have to go for other tricks to rotate or reflect your vectors.

So yes, I'm sure. (0,1)˛ = (-1,0) is just overly bloated for something that can just as well be written as i˛=-1.

Title: Re: complex not so complex
Post by: M Benesi on June 06, 2013, 01:24:01 AM
Quote from: s31415 on June 05, 2013, 10:18:23 AM
This is a good example of what happpens when using a non-conformal map. The small scale patterns are stretched and unrecognizable.
  No they aren't, just like the "circles" in the 2d Mset aren't unrecognizable (although they aren't perfect circles, except that one period bulb).  Just zoom in (well- not that image, you need to zoom into the fractal with a decent 3d fractal generator). 

  The same pattern is repeated throughout.  You just zoom in.  Everything repeats, with some variation- things have more "spokes" when you zoom into certain areas (similar to 2d p/q type relations).

Title: Re: complex not so complex
Post by: jehovajah on June 06, 2013, 05:27:16 AM
For anyone not quite sure what is the mathematical differences here, just realise that it is over which notation or terms to use to describe exactly the same behaviours. So it is like one saying it sounds sweeter in Italian, while another is saying it is clearer in German.

The intuition that gets lost in this kind of debate is what drives innovation, new solutions, different viewpoints.

The thing here is to go with the flow and see where it takes us. We will go over old ground as well as new, but hopefully with our eyes and ears and intuition apprehending things slightly differently, which may lead us to the goal we seek, the holy grail.

Kram1032 this reminds me so much of your work on conformal actions, or maybe it was Tglad's.
I will look it up. :embarrass:

Its Tglad's
http://www.fractalforums.com/new-theories-and-research/new-type-of-fractal/

Title: Re: complex not so complex
Post by: s31415 on June 06, 2013, 09:24:56 AM
Quote from: M Benesi on June 06, 2013, 01:24:01 AM
  No they aren't, just like the "circles" in the 2d Mset aren't unrecognizable (although they aren't perfect circles, except that one period bulb).  Just zoom in (well- not that image, you need to zoom into the fractal with a decent 3d fractal generator). 

  The same pattern is repeated throughout.  You just zoom in.  Everything repeats, with some variation- things have more "spokes" when you zoom into certain areas (similar to 2d p/q type relations).

I don't know what you mean. This fractal has obviously been created by iterating a non-conformal map of the Mandelbulb type. What looks like almost smooth rings are overly stretched versions of the pattern. Of course, this doesn't mean that there are no small scale detail. Just that they are stretched, some of them beyond recognition. This is not what happens in the M-set.

Title: Re: complex not so complex
Post by: puntopunto on June 06, 2013, 10:10:33 AM
@kram1032
You missing my point. I try to discuss the possible introductions of complex numbers. Which notations, representations and naming you can use. And which consequence that has. Not about how you or someone else, should/would do it in the end. That this is important I can show you with your first remark:
Quote
Puntopunto, "normal" vector algebra doesn't even have a vector product defined.
But there is, they named it only different. So if I say: "Take the 2D vector space with complex multiplication and addition Then expressions like v2+3v, even log(v)  makes perfectly sense.
And no you don't have to define extra things. If complex numbers are introduced as ordered pairs of reals, there is simply no more to define then as with
the introduction with a+bI In fact there is one thing less, the definition of i.
Starting with ordered pairs, you stay closer to the representation as points/vectors of complex numbers. And there is no need for the mathematical incorrect definition of i with the square root of -1. And there are also disadvantages, you miss the analogy with the notation system we use for the reals.

Title: Re: complex not so complex
Post by: puntopunto on June 06, 2013, 11:12:11 AM
@jehovajah

Your description in your last post describes very well what it is about.


Title: Re: complex not so complex
Post by: Roquen on June 06, 2013, 12:08:19 PM
I'm half agreeing and half disagreeing with what you're say.  To be semi-formal then you could say something like: complex numbers form a 2 dimensional vector space with basis set {1,e} over field F.  axiom 1: e2=-1.  Now you can demonstration the form of the product over an arbitrary field.  We can then limit the field to reals, add the rule for conjugation and then develop the full algebra in terms of geometric operations.  Since 'e' is only used in formulation of the product, we can certainly not look at it again except to translate historic formalism to whatever form individually works.  Personally I likewise use a tuple notion for most things:  I certainly would never write a 3D vector as:  v = x e0 + y e1 + z e2, because it's too verbose and requires slight more work to decipher vs. (x,y,z).  The same for writing a complex as (x,y).  So here we seem to be in agreement.  My attempted point is the system you're describing could be equivalent described in complex and retain the ability of algebraic reasoning (although I admit than fold introduces a problem).

Quote from: kram1032 on June 05, 2013, 05:07:33 PM
Puntopunto, "normal" vector algebra doesn't even have a vector product defined. I mean, there are the scalar and the cross products, but the former gives you a scalar and the later only works in 3D.
It's true that vectors don't have a product.  The dot product doesn't close, it produces a scalar.  But the cross product also doesn't close it returns a bi-vector/pseudo-vector/etc. (poor physics folks).  And from a vector-centric view point the cross product is only definable in 3D.  But from a complex view-point:  X=(a,b), Y=(c,d), X*Y = (a,b)*(c,d) = (a,-b)(c,d) = (ac+bd, ad-bc).  So from a projection standpoint you get the parallel and orthogonal projections and the results are in the expect positions.  Oh!  Hello difference of angles identity!

Title: Re: complex not so complex
Post by: kram1032 on June 06, 2013, 01:14:54 PM
I guess I'm fine with switching between notations when ever one is more practical than the other.
In case of (0,1)²=(1,0) vs. i²=1, the later clearly is less verbose.

Though yeah, vectors do not have a true vector multiplication defined on them within vector calculus.
And clifford algebras are exactly defined by how you multiply vectors together. So once you do define multiplication on vectors, you already are doing clifford algebras, unless you choose a very different way of doing it.

As long as you just stay with vectors, doing a tuple notation is fine. But if you go into the details of adding a scalar, some bivectors and possibly even other structures, you'd end up with something like (example 3D space)

a+(x,y,z)+(yz,zx,xy)+xyz

Two three-tuples and two scalars, or alternatively

(a,x,y,z,yz,zx,xy,xyz)
an 8-tuple.

The addition part with mixed tuples and non-tuples is kinda weird and if you go all tuples, the individual meaning of each component is kinda lost in the notation.
And if you don't distinquish vectors from bi-vectors, which is entirely possible, you'll end up with "axial" and "polar" vectors which you have to be really careful with, because they act differently under reflections.

So as long as you only need vectors or only bivectors or something like that, grouping them together is probably a good idea, but if you need to manipulate the full object, you're probably better off with splitting it all into a sum-of-components notation.

And for the 2D case, the complex notation* is actually less verbose than the tuple one:
(x,y) vs x+iy
You save one symbol.
Or at worst, it's of equal verbosity:
\left({x \\ y}\right)

Either way, my main point actually wasn't about the notation but rather about the fact that, if you're doing vector products, you're no longer strictly doing vector algebra.

*There's one caveat in that, technically, 2D euclidean space corresponds to 1+x+y+xy.
When you're working with the normal vector part, you only have (x,y), while (1,xy) is like what you'd do in complex numbers. If you define x and y both to square to -1, this actually will give you quaternions 1+i+j+ij = 1+i+j+k, so in a geometric sense, quaternions actually describe a 2D space with i and j being its vectors, while k=ij describes the entire plane, a bivector and also a pseudo scalar.
But that's a different story... As many other simplifications are possible, to my knowledge, all you can do in 2D can be done equally well with complex numbers.
Though I'm not sure on that. Maybe there are some things in 2D which would benefit from full quaternion or other 2D geometric algebra description.
But even then, which notation best to choose would depend on the context.

Title: Re: complex not so complex
Post by: puntopunto on June 06, 2013, 03:59:58 PM
Quote
I try to discuss the possible introductions of complex numbers. Which notations, representations and naming you can use. And which consequence that has. Not about how you or someone else, should/would do it in the end. That this is important I can show you with your first remark:

Quote:
Puntopunto, "normal" vector algebra doesn't even have a vector product defined.

But there is, they named it only different.

They named it rotation

Title: Re: complex not so complex
Post by: Roquen on June 06, 2013, 05:10:14 PM
@kram1032:  The notation portion here is mostly "much ado about nothing".  You need an expanded notation to formally construct, demonstrate a property, explain a concept, to look for "what I'm I missing here?" and to complete a derivation.  Otherwise you're going to be working purely symbolically.  The tuple notation simply fits my brain better...partly because I'm a programmer.  Still I'd do - standard 2D model: X = (s, v, b) = (s, (vx,vy,vz), b).  Say ~X is grade reversal: ~(s,v,b) = (b,v,s).  Standard 3D model: (s, v, b, t) = (s, (vx,vy,vz), (bx,by,bz), t).  Multi-vector algebra tend to have a fair number of null-vectors, so the form of say (s,0,b,0) jumps out at me faster.  If I were to start playing around with 3D conformal GA you couldn't pay be to write out all 32 terms.  Another potential benefit is when are are looking a different mathematical types, which are related:  say complex numbers and quaternions.  But seriously I can't see this sub-topic as being very important.

WRT: Quaternions - although they can be used to represent a 2D projective space, a 3D interpretation is much more natural (i.e. 3D bivector plus scalar).

Title: Re: complex not so complex
Post by: kram1032 on June 06, 2013, 05:40:36 PM
Rotation within vector algebra would typically be done via rotational matrices, right?
That's matrix multiplication and is undefined for equally shaped vectors.

Title: Re: complex not so complex
Post by: M Benesi on June 12, 2013, 02:07:04 AM
Quote from: s31415 on June 06, 2013, 09:24:56 AM
I don't know what you mean. This fractal has obviously been created by iterating a non-conformal map of the Mandelbulb type. What looks like almost smooth rings are overly stretched versions of the pattern. Of course, this doesn't mean that there are no small scale detail. Just that they are stretched, some of them beyond recognition. This is not what happens in the M-set.

  You're right.  :p

Title: Re: complex not so complex
Post by: jehovajah on July 15, 2013, 09:52:55 AM
Some very nice discussion here about the crucial role of symbolic notation in making the Algrbra more or less intuitive than the geometry.

If you have not read Hermann Grassmann's 1844 Ausdehnungslehre, in German, I highly recommend it for this part of the discussion. Die Ableitung der Begriffe I think is the chapter, excuse my poor German.



Powered by SMF 1.1.21 | SMF © 2015, Simple Machines