Mark
Dow
Geek art
Simple recursive systems and fractal patterns
2x2 symmetric L-systems
The simplest 2x2 replacement systems with rules that are globally and locally symmetric and self-symmetric (see
symmetries of block replacement L-systems).
Many other types of systems also have a large number of symmetries, for example:
Two symbol systems
The two most symmetric 2-symbol 2x2 system
that have a unique 2-D pattern (up to rotation and/or swap of symbols),
are the 2-D Thue-Morse system and a plain checkerboard.
[To Do: Representation of TM and CB.]
Three symbol symmetric systems with two terminating rules
A simple static system that terminates at the first generation, included for completeness.
This system is not reccurent; the second (gray) rule is only
visited once, at the 1st generation. And while the first and last rules
refer to
themselves, they only refer to themselves and so leave the system's pattern the same.
Note that the second (gray) rule is only visited once, at the 1st generation.
Matlab command:
>> imOut = L_system_tiling( 'BF', [ng], 3, 1, 0, '', 1, [0 0; 0 0], [0 2; 0 2], [2 2; 2 2] );
where [ng] is the number of generations.
Any square region centered anywhere on the diagonal
is geometrically similar to any other such region at every generation.
This system can be considered as a simple tally
number system, where each column is a set of 0's and 1's. The the number of 1's in a column represents an integer,
increasing from left to right. The gray symbol/rule would represent a
generator that takes a number (the current column value), multiplies by
two and adds 0 (n, null) and 1 to generate a pair of columns, each with a single new generator. Starting with the generator g, the system generates all integers (a tally of contiguous 1's) with no duplicates:
g -> n g -> n n n g ...
g 1 n n g 1
n g 1 1
g 1 1 1 where each pair of columns is generated from a previous column,
____________________________
0 -> 0 1 -> 0 1 2 3 ... and the number of 1's represents an integer.
Matlab command:
>> imOut = L_system_tiling( 'BF', [ng], 3, 1, 0, '', 1, [0 0; 0 0], [0 1; 1 2], [2 2; 2 2] );
where [ng] is the number of generations.
The pattern is a binary fractal--
the white and black regions are mirror image of each other, and the
bottom two quadrants are both scaled copies of the whole. It is also a
fractal tiling with a fractal (but finite boundary length) prototile.
All singularities are on a line at the bottom.
This system "grows" by adding a new periodic row of
binary symbols [To Do: Show the 1-D periodic binary system.], at twice
the spatial frequency (same phase at the left and right, an at the
beginning of every even cycle) and half the height of the row above it.
The system can be considered as a binay tally
system, where each column is a set of binary elements, numerically
increasing from left to right. The gray symbol/rule would represent a
generator that takes a number (the current column value), multiplies by
two and adds 0 (n, null) and 1 to generate the next pair of columns, each with a single new generator. Starting with the generator g, the system generates all integers (a tally of contiguous 1's) with no duplicates:
[To Do: Same style diagram as above, compare the systems.]
Matlab command:
>> imOut = L_system_tiling( 'BF', [ng], 3, 1, 0, '', 1, [0 0; 0 0], [0 2; 1 1], [2 2; 2 2] );
where [ng] is the number of generations.
Periodic alternating bits system
Matlab command:
>> imOut = L_system_tiling( 'BF', [ng], 4, 1, 0, '', 1, [0 0; 0 0], [0 3; 2 2], [3 0; 1 1], [3 3; 3 3] );
where [ng] is the number of generation
Four symbol symmetric systems with two terminating rules
Reflected binary (Gray) code system
Each row is a Thue-Morse sequence
(with white and black as symbols) with symbols that double in size between rows. The number represented by each
column (the number of white pixels, or the binary number encoded in the column's symbols) maps the column's index
(0, 1, 2, 3, 4... from left to right) to the Gray code position of that column's index (0, 1, 3, 2, 7, ...).
The name "Reflected binary system", because of its
relationship to the reflected binary (Gray) code, is a bit misleading.
Notice that the pattern and self-similarity diagram do not contain a
reflection (mirror) symmetry about the central vertical. The left and
right halves are related by a swap of the left and right and a swap of
symbols (black <-->white and dark gray <--> light gray).
The rows of the pattern, from top to bottom, alternate between
a swap of symbol symmetry and a mirror symmetry. The bottom row
(all dark or light gray) alternate between these two symmetries by
generation.
Another rendering of this basic pattern is found in Stephen Wolfram's "A New Kind of Science", page 83, figure b.
The Gray code, also known as the reflected binary code, forms a Hamiltonian cycle on a hypercube where each bit represents one dimension
Matlab command:
>> imOut = L_system_tiling( 'BF', [ng], 4, 1, 0, '', 1, [0 0; 0 0], [0 3; 1 2], [3 0; 2 1], [3 3; 3 3] );
where [ng] is the number of generations.
Each column contains a unique number of white (and
black) pixels, so this pattern can be viewed as a reordering of
integers. If the number of white pixels in sequential columns is
expressed as a binary number, the rows are periodic. The bottom row has
period 2 and each row above the period increases by a factor of 2 (4,
8, 16 ...). The third generation sequence, for example, contains this
sequence of white voxels:
0 0 0 0 0 0 0 0 <- period 16
1 1 1 1 0 0 0 0 <- period 8
0 0 1 1 0 0 1 1 <- period 4
1 0 1 0 1 0 1 0 <- period 2 binary (vertical column, least significant bit at bottom)
_______________
5 4 7 6 1 0 3 2 decimal
The number of black voxels is the bit-wise complement of this sequence.
This ordering of integers is related to nimbers, in particular nim-sum sequences (for example Sloane's A004462, nimsum n + 21).
Matlab command:
>> imOut = L_system_tiling( 'BF', [ng], 4, 1, 0, '', 1, [0 0; 0 0], [2 0; 3 2], [0 1; 1 3], [3 3; 3 3] );
where [ng] is the number of generations.
Matlab command:
>> imOut = L_system_tiling( 'BF', [ng], 4, 1, 0, '', 1, [0 0; 0 0], [0 2; 2 0], [1 3; 3 1], [3 3; 3 3] );
where [ng] is the number of generations.
Three-legged diagonal system
Matlab command:
>> imOut = L_system_tiling( 'BF', [ng], 4, 1, 0, '', 1, [0 0; 0 0], [0 2; 2 0], [3 1; 1 3], [3 3; 3 3] );
where [ng] is the number of generations.
Three-legged inverse diagonal system
Matlab command:
>> imOut = L_system_tiling( 'BF', [ng], 4, 1, 0, '', 1, [0 0; 0 0], [0 2; 2 3], [3 1; 1 0], [3 3; 3 3] );
where [ng] is the number of generations.
Matlab command:
>> imOut = L_system_tiling( 'BF', [ng], 4, 1, 0, '', 1, [0 0; 0 0], [0 2; 2 1], [2 1; 1 0], [3 3; 3 3] );
where [ng] is the number of generations.
Matlab command:
>> imOut = L_system_tiling( 'BF', [ng], 4, 1, 0, '', 1, [0 0; 0 0], [0 3; 2 2], [1 1; 3 0], [3 3; 3 3] );
where [ng] is the number of generations.
Alternating half-rotation system
Matlab command:
>> imOut = L_system_tiling( 'BF', [ng], 4, 1, 0, '', 1, [0 0; 0 0], [0 3; 1 2], [2 1; 3 0], [3 3; 3 3] );
where [ng] is the number of generations.
Alternating rotate inverse system
Matlab command:
>> imOut = L_system_tiling( 'BF', [ng], 4, 1, 0, '', 1, [0 0; 0 0], [0 3; 3 2], [0 1; 3 0], [3 3; 3 3] );
where [ng] is the number of generations.
Matlab command:
>> imOut = L_system_tiling( 'BF', [ng], 4, 1, 0, '', 1, [0 0; 0 0], [0 3; 0 2], [3 1; 3 0], [3 3; 3 3] );
where [ng] is the number of generations.
Matlab command:
>> imOut = L_system_tiling( 'BF', [ng], 4, 1, 0, '', 1, [0 0; 0 0], [0 0; 0 2], [3 1; 3 3], [3 3; 3 3] );
where [ng] is the number of generations.
Matlab command:
>> imOut = L_system_tiling( 'BF', [ng], 4, 1, 0, '', 1, [0 0; 0 0], [0 0; 0 2], [1 3; 3 3], [3 3; 3 3] );
where [ng] is the number of generations.
Five symbol symmetric systems with two terminating rules
Matlab command:
>> imOut = L_system_tiling( 'BF', [ng], 5, 1, 0, '', 1, [0 0; 0 0], [0 2; 2 0], [1 3; 3 1], [2 4; 4 2], [4 4; 4 4] );
where [ng] is the number of generations.
Binary tally to diagonal split system
The pattern is also a binary fractal
-- with the same scale symmetries as the binary tally system alone. Note that the diagonal split rules are seperable
from (don't refer to) the binary tally rules.
[To Do: Finish description. Note that diagonal generators occur along
diagonal boundaries as well as on bottom row -- show blow-up of a
triangle top tip.] [To Do: What system has a 2:1 diagonal split, such that it could
replace rules 1 and 3 to get continuous boundaries? I suspect it is
4-symbol, with 2 terminating rules. The binary tally to binary split system (below) achieves a 2:1 diagonal split along with a stepped boundary.]
[To Do: Diagonal split to binary tally system.]
Matlab command:
>> imOut = L_system_tiling( 'BF', [ng], 5, 1, 0, '', 2, [0 0; 0 0], [0 1; 1 4], [1 3; 2 2], [3 0; 4 3], [4 4; 4 4] );
where [ng] is the number of generations.
Binary tally to mirrored diagonal split system
Matlab command:
>> imOut = L_system_tiling( 'BF', [ng], 5, 1, 0, '', 2, [0 0; 0 0], [1 4; 0 1], [1 3; 2 2], [4 3; 3 0], [4 4; 4 4] );
where [ng] is the number of generations.
Binary tally to binary step system
The pattern is also a binary fractal
-- with the same global scale symmetries as the binary tally system
alone. Note that the binary split rules (2nd and fourth rules) are
seperable
from (don't refer to) the binary tally rules. The binary split rule
alone is not symmetric -- there is an imbalance of black/white in the
top two quadrants -- but the pair have mirror-inversion symmetry.
[To Do: What system has a 2:1 diagonal split, such that it could
replace rules 1 and 3 to get continuous boundaries? I suspect it is
4-symbol, with 2 terminating rules.]
Matlab command:
>> imOut = L_system_tiling( 'BF', [ng], 5, 1, 0, '', 2, [0 0; 0 0], [0 1; 0 4], [1 3; 2 2], [3 4; 0 4], [4 4; 4 4] );
where [ng] is the number of generations.
Diagonal split to binary tally system
The pattern is also a binary fractal
-- with the same global scale symmetries as the binary tally system
alone. Note that the binary split rules (2nd and fourth rules) are
seperable
from (don't refer to) the binary tally rules. The binary split rule
alone is not symmetric -- there is an imbalance of black/white in the
top two quadrants -- but the pair have mirror-inversion symmetry.
[To Do: What system has a 2:1 diagonal split, such that it could
replace rules 1 and 3 to get continuous boundaries? I suspect it is
4-symbol, with 2 terminating rules.]
Matlab command:
>> imOut = L_system_tiling( 'BF', [ng], 5, 1, 0, '', 2, [0 0; 0 0], [0 4; 1 1], [1 2; 2 3], [4 0; 3 3], [4 4; 4 4] );
where [ng] is the number of generations.
Diagonal split to rotated binary tally system
Same as Diagonal split to binary tally system (above) but with the second rule mirrored about the horizontal.
Matlab command:
>> imOut = L_system_tiling( 'BF', [ng], 5, 1, 0, '', 2, [0 0; 0 0], [1 1; 0 4], [1 2; 2 3], [4 0; 3 3], [4 4; 4 4] );
where [ng] is the number of generations.
Diagonal split to rotated mirrored binary tally system
Same as Diagonal split to binary tally system but with the second rule rotated about the horizontal.
Matlab command:
>> imOut = L_system_tiling( 'BF', [ng], 5, 1, 0, '', 2, [0 0; 0 0], [1 1; 4 0], [1 2; 2 3], [4 0; 3 3], [4 4; 4 4] );
where [ng] is the number of generations.
Six symbol symmetric systems with two terminating rules
Matlab command:
>> imOut = L_system_tiling( 'BF', [ng], 6, 1, 0, '', 2, [0 0; 0 0], [1 0; 5 1], [2 3; 5 1], [2 3; 4 0], [5 4; 4 0], [5 5; 5 5] );
where [ng] is the number of generations.
Seven symbol symmetric systems with two terminating rules
Binary tally to binary step to diagonal split system
This system was designed by serially compositing of more simple systems, including the binary tally and diagonal split systems:
The pattern is also a binary fractal
-- with the same global scale symmetries as the binary tally system alone.
"Bracket" tilings
 |
|
|
| This unit shape (or its
bilateral mirror double) and its scaled copies can tile the plane in
several other interesting ways. It is a fractal with one singularity,
at the bottom tip. |
A copy ot the central pattern, scaled by 2+-n/2 and rotated by pi/4, fits (with no gap) onto the original pattern. |
Four rotations of this (center) cover a truncated square.
In addition to its four-fold rotational symmetry, this pattern has an
odd (color inverse) symmetry about the horizontal, vertical
and both diagonal axes. |
Matlab command:
>> imOut = L_system_tiling( 'BF', [ng], 7, 1, 0, '', 2, [0 0; 0 0], [0 1; 1 6], [0 1; 0 6], [2 4; 3 3], [5 6; 0 6], [5 6; 0 5], [6 6; 6 6] );
where [ng] is the number of generations.
[To Do: When the whole system has rotational symmetries, the base of
the scale-symmetry diagram should show these symmetries, as well as
intra-quadrant scale-symmetries. Modify L_system_tiling.m to generate
this properly.]
Matlab command:
>> imOut = L_system_tiling( 'BF', [ng], 7, 1, 0, '', 3, [0 0; 0 0], [4 5; 3 2], [2 0; 6 4], [6 3; 5 0], [2 6; 0 4], [0 3; 5 6], [6 6; 6 6] );
where [ng] is the number of generations.
Square wave quarter-twist system
Matlab command:
>> imOut = L_system_tiling( 'BF', [ng], 7, 1, 0, '', 1, [0 0; 0 0], [11 12; 10 9], [6 0; 12 0], [9 0; 0 0], [6 10; 6 0], [6 6; 6 11], [6 6; 6 6] );
where [ng] is the number of generations.
Matlab command:
>> imOut = L_system_tiling( 'BF', [ng], 7, 1, 0, '', 1, [0 0; 0 0], [11 12; 10 9], [1 0; 12 0], [9 0; 0 0], [6 10; 6 1], [6 6; 6 11], [6 6; 6 6] );
where [ng] is the number of generations.
Square wave half-twist system
Matlab command:
>> imOut = L_system_tiling( 'BF', [ng], 7, 1, 0, '', 1, [0 0; 0 0], [17 18; 16 19], [6 0; 18 0], [19 0; 0 0], [6 16; 6 0], [6 6; 6 17], [6 6; 6 6] );
where [ng] is the number of generations.
------------------------------------
There are no restrictions on use of the images on this page. Claiming to be the originator of the material,
explicitly or implicitly, is bad karma. A link (if appropriate), a note to dow[at]uoregon.edu, and credit are appreciated but not required.
Comments are welcome (dow[at]uoregon.edu).
