**The 'Boulanger' Transformation**
** **
**
RICCI Sophie**

**Cycles
and Convergence as for x transform**ation

EXIT

The Boulanger transformation finds its strange name in its physical representation that remains how the baker kneads the dough.

Just like stretching, cutting and folding the dough, the 'Boulanger' Transformation comes up to changing a square into an other one as follows:

We will study more seriously the x transformation that is easily described by the graph and its critical points:

This dynamic system is highly sensible to initial conditions in x and y. If there is no contraction, the area of the initial square is conserved, otherwise, the area is contracted.

The sensibility to initial conditions leads to specific behavior so that we can underline three main types of initial conditions.

The simulation will be written in fortran 90 and compiled with Lahey.

The structure of the transformation implies that the number be coded in binary and that the program takes into account the numerical errors in the runs in order to draw the attractor.

The Boulanger transformation** **could,
at first sight, be written very simply as it just multiplies number by
2 or almost. Nevertheless, if the program is written this way it appears
that the results all converge to zero. This surprising result is the consequence
of the numerical calculation in the runs.

It is easier to understand if we write the number in binary, just like a computer.

Any number will be coded by a given number of 0 and 1 depending on the precision of the machine, and whatever its real binary expression, the computer will only keep a ffew first ones.

Than occurs f(x), that on [0;1] is equivalent to pushing the binary list to the left one step an iteration, as a consequence, after a given number of iterations all the binary list has been pushed out and the number is 0. It will remain to 0 for the following iterations.

x0: 0 1 1 0 0 1

x1: 1 1 0 0 1

x2: 1 0 0 1

x3: 0 0 1

x4: 0 1

x5: 1

x6: 0

x7: 0

x8: 0 .......

Here come two solutions: We could write as many 0 and 1 as the number of iterations, which is not very easy, or decide to add on 0 or 1 at the end of the binary list for each iteration. This is what is done is the following program.

The first binary list is randomized, so are the 0 and 1 added in the loop over the iterations.

As a consequence, we don't decide of the initial condition, and even more , we need to run all the program until the end to have the global initial vector (size = number of iteration + size of the first randomized vector)

If we want to treat specific initial condition such as rationnals, the code must be rewritten.

*Theory:*

As a dynamic system, we can look for the stability and instabilities of the 'Boulanger 'transformation.

- The critical points for the transformation in x are such
as f(xe)=xe, so xe=0 or xe=1

- The critical points for the transformation in y are such
as f(ye)=ye, so ye=0 if xe=0

So the only possible critical point is (0,0) for the 2d system.

Anyway, the matrix of the system close to 0 is

- 2 ; 0

0 ; beta/2

*Simulation:*

Strating from x=0, y=0.25, the system converges normally to (0,0). The critical point is an instable point of balance.

Strating from x=1, y=0.7, the system converges to (1,y1). Y1 depends of Y0 and of the coefficient of contraction.

**Cycles
and Convergence as for x transformation**

In this study we must distinguish 3 types of points in x:

-The cycle ones

-The ones sticking to 0

-The ones going to the attractor

`Zero
numbers`

To go futher here we should better write the numbers in binary, effectivly it will be easier to find the cycles and the 0 points.

As shown by the graph of the transformation in the introduction, applying f to x means pushing its binary writting of one step to the left, so that the binary decimal will disappear one by one for each iteration.

First we will consider the numbers that can be written as q/2^p:

It implies that their writting in binary decimal is not infinite and that after a given number of iteration f will lead to 0.

Let 's take the example of x0=3/2^4

x0=3/16

x1=3/8

x2=3/4

x3=1/2

x4=0

*cycles*

The rationnals also have an special binary writting, effectivly, the serie of 0 and 1 must be periodic.As a consequence f will lead to a given number of values for a rationnal x0, we call it a cycle.

We can give several example of those cycles:

Cycle for 1/3 * 1/2^p: 1/3 ; 2/3 ; 1/3

Cycle for 1/5 * 1/2^p: 1/5; 2/5; 4/5; 3/5; 1/5

Cycle for 1/7 * 1/2^p: 1/7; 2/7; 4/7; 1/7

Cycle for 1/9 * 1/2^p: 1/9; 2/9, 4/9; 8/9; 7/9; 5/9; 1/9

Cycle for 3/7 * 1/2^p: 3/7; 6/7; 5/7; 3/7

*Attractor*

The other numbers, what means the irrationals will take any value between 0 and 1 , and as for y will describe a specaial shape, this leads to the appearence of an attractor.

The domain will be describe in the following part.

If beta is egal to 1 there is no contraction of the surface and no attractor, but, if we consider beta<1, than appears the attractor covering as supposed the all interval [0,1]

The shape of the attractor cover the all domain in x bu it's position in y depends on two parametres:

-the coefficient of contraction

-the initial condition in y

As seen on the following graphs, the attractor consists in 4 blocks of points more or less fat. The 2 first graphs represent 1000 iterations and the others are for 10 000. The greater beta gets, the thicker are teh blocks, effectivly this represents the contraction of the area.

After a few iterations only, the points stick to the attractor going from blocks to blocks.

One of the most interesting part of the subject was the fortran part, effectivly the coding inbinary and the necessity to keep on constructing the vector in the loop was pretty unusual. We can notice here how careful we must be using computational methods and simulations: the precision of the machine was here a very important element.

The transformation in x leads to very particular behavior, especially the cycles, the difference between rationnals and irrationals is here crucial.

Then the attractor shows the influence of the transformation in y.

One interesting idea would be to know how the point goes from block to block. We could estimate the distance between each iteration.