Midterm Project: L-systems in Practice and Theory

Transcription

1 Midterm Project: L-systems in Practice and Theory Joey Gonzales-Dones March 28, Introduction Lindenmayer systems, or L-systems, are systems for algorithmically rewriting a string of characters. Given a string µ over an alphabet V (µ V ), a set of productions P is used to replace substrings of µ to form a new string over V. The system must also include an axiom string, ω, which represents its initial state. (An L-system can formally be represented as a 3-tuple G = (V, ω, P ), using the same elements defined above.) L-systems are similar to Chomsky grammars, another category of string rewriting systems, and have similar naming conventions (context-free, context-sensitive). However, in Chomsky grammars, productions are applied one at a time, whereas in L-systems, productions are simultaneously applied to the whole string. This makes L-systems strictly more powerful than their corresponding grammars. [1, 1-3]. For example, the set {x a : x = 2 n, n 0} (i.e., all strings of all as whose length is a power of 2), is not generated by any context-free grammar (proof omitted for brevity s sake; see [2, 153] for the general idea), but it is generated by the context-free L-system V : {a} ω: a P : {a aa} Given the axiom a, we can apply the system s rule a aa to produce the string aa, then apply the same rule on both of the as simultaneously to produce the string aaaa. We could then produce aaaaaaaa using a third iteration, and so on. In addition to generating formal languages, the strings that L-systems generate can, when interpreted suitably, create mathematically interesting graphics, including fractals and plant-like shapes. 1

2 2 Graphical Interpretations Consider the Koch snowflake, a fractal formed by taking an equilateral triangle and recursively replacing each straight edge with a generator figure, as Prusinkiewicz and Lindenmayer illustrate in their book. Figure 1: An illustration of how the Koch snowflake is constructed. [1, 2] The book brings up the Koch snowflake as an example of the initiator and generator pattern without explicitly giving the the L-system that produces it. However, if we take an L- system that operates on strings and assign to each character an operation using turtle graphics (a system consisting of an imaginary turtle with a pen with a location point (x, y) R 2 and an orientation angle α R. See [1, 7] for a more in-depth explanation), we can easily use L-systems to produce graphical patterns. Using the Koch snowflake example, notice that the equilateral triangle initiator can be produced with turtle graphics using the following sequence of steps: 1: Draw forward 1 unit 2: Turn right by 120 (i.e., 60 twice) 3: Draw forward 1 unit 4: Turn right by 120 (i.e., 60 twice) 5: Draw forward 1 unit 2

3 Meanwhile, the generator can be produced with turtle graphics using the following sequence of steps: 1: Draw forward 1 unit 2: Turn left by 60 3: Draw forward 1 unit 4: Turn right by 120 (i.e., 60 twice) 5: Draw forward 1 unit 6: Turn left by 60 7: Draw forward 1 unit This suggests that we can produce the Koch snowflake with the following L-system: V : {A,, +} ω: A A A P : {A A + A A + A} with turtle interpretations A: Draw forward 1 unit +: Turn left by 60 : Turn right by 60. Note that there are no productions with + or on their left-hand sides; it is assumed in this case that the identity productions + + and hold. The first few strings produced by this L-system are: 0: A A A 1: A+A A+A A+A A+A A+A A+A 2: A+A A+A+A+A A+A A+A A+A+A+A A+A A+A A+A+A+A A+A A+A A+A+A+A..., 3

4 We see that this does indeed produce the Koch snowflake. Figure 2: The starting state and the first 4 iterations of an L-system that generates the Koch snowflake, visualized with OpenSCAD. For this and for subsequent examples, I wrote a Java program to represent an arbitrary L- system, and then for each example, another Java program to interpret the L-system string and carry out the turtle s actions. Rather than having the Java program draw directly, I decided to have it produce an OpenSCAD file using the turtle s position at each step. More specifically, the OpenSCAD file creates an ordered list (p 1, p 2,..., p k ) of rectangular prisms at each of the points the turtle visits, and then produces the convex hull of prisms p i and p i+1 for all i k 1, which creates a wall along the turtle s path. For another example (taken from Wikipedia), this is an L-system to produce the Sierpinski triangle, another common example of a fractal. V : {F, G,, +} ω: F G G P : {F F G + F + F F, G GG} 4

5 with turtle interpretations F, G: Draw forward 1 unit +: Turn left by 120 : Turn right by 120. Figure 3: The 5th iteration of an L-system that generates the Sierpinski triangle [3], visualized with OpenSCAD. Figure 4: A 3D print I made from the model in the above figure. 5

6 3 Stochastic L-systems So far, all the examples of L-systems have belonged to the simplest class, deterministic context-free L-systems, or DOL-systems. Since they are deterministic, DOL-systems will always produce the exact same string every time their productions are applied on the starting axiom. This is uninteresting and unrealistic when trying to model real-life objects such as plants. However, stochastic (context-free) L-systems have for each symbol in their alphabet a set of possible productions, along with a probability distribution π : P (0, 1], which maps to each production a probability that it will be chosen in a derivation. (A stochastic L-system is thus formally be represented as a 4-tuple G = (V, ω, P, π). [1, 28]). For a simple example, consider the stochastic L-system V : {A, a} ω: A P : {A 0.75 AA, A 0.25 a} Every time a production with left-hand side A occurs, there is a 75% chance of applying the production A AA, and a 25% chance of applying the production A a. Since there are no listed productions with a on their left-hand side, it is assumed that the identity production a 1.00 a holds. Here s an example 10-step derivation of this system: 0: A 1: AA 2: AAa 3: AAAAa 4: AAaaAAa 5: AAaaaaaa 6: AAAAaaaaaa 7: AAAAAAAAaaaaaa 8: AAaaAAAAAAaAAaaaaaa 9: AAAAaaAAAAAAaAAAAaaaaaaaaa 10: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa I made up my own interpretation for this system as follows. When interpreting the ith character: A: Draw a red rectangular prism at the coordinate x = i a: Draw a yellow rectangular prism at the coordinate x = i 6

7 Figure 5: The interpretations in OpenSCAD of four different derivations (for n = 10) of the stochastic L-system given above. (Note that the viewport is the same in all four images.) Here s another example, taken from Prusinkiewicz and Lindenmayer ([1, 28]): V : {F, +,, [, ]} ω: F P : {F 0.33 F [+F ]F [ F ]F, F 0.33 F [+F ]F, F 0.34 F [ F ]F } Again, we use a (slightly more complicated) turtle interpretation. This time, the turtle also has a stack (a data structure where an item may only be pushed onto or popped off of the top, which means data enters the stack in a last-in, first-out manner.) F : Draw forward 1 unit +: Turn left by δ : Turn right by δ [ : Push the turtle s current position and angle onto the stack ] : Pop the stack and set the turtle s current position and angle to the values that were popped. 7

8 As a result of introducing the brackets to the L-system s alphabet, it can create branched structures that resemble simple trees: Figure 6: Five trees rendered in OpenSCAD, using the above L-system and interpretation for n = 5 iterations, and a change in angle of δ = 20. 8

9 Figure 7: A close-up view of the trees in the previous figure. 4 Context-sensitive L-systems Another variation of L-systems are known as context-sensitive L-systems; this means that the symbol on the left, on the right, or on both sides of the current symbol (the strict predecessor) determines which production to apply. For example, the production a l < a > a r χ means Apply the rule a χ if and only if the symbol a l is to the immediate left of a and a r is to the immediate right of a. [1, 30] Context-sensitive L-systems can model more complex phenomena than context-free L-systems. Prusinkiewicz and Lindenmayer given an example involving signal propagation: V : {b, a} ω: baaaaaaaa P : {b < a b, b a} Notice that this system contains both a context-sensitive and context-free production; in that case that they both have the same strict predecessor, the context-sensitive production takes precedence. [1, 31] This system produces the following strings: 9

10 0: baaaaaaaa 1: abaaaaaaa 2: aabaaaaaa 3: aaabaaaaa 4: aaaabaaaa 5: aaaaabaaa 6: aaaaaabaa 7: aaaaaaaba 8: aaaaaaaab 9: aaaaaaaaa After iteration 9, the system does not change further (i.e., only the identity production a a is ever applied). It is more complicated to implement context-sensitive L-systems with brackets, which are useful for generating tree structures. In this case, the symbols to the immediate left and right of the strict predecessor may not be the correct left and right contexts, and thus we may need to skip over an arbitrary number of symbols to find the correct contexts. [1, 32] 5 Future Work Although I feel that I accomplished a lot over the course of this project, there are many more ways I could explore L-systems in the future. I did not have the time to implement bracketed contextsensitive L-systems, and thus do not have any interesting graphical models to show involving them. There is also one more important class of L-systems, parametric L-systems, which come in both context-free and context-sensitive varieties. Parametric L-system strings consist of modules, which are made of letters A V with associated sequences of parameters a 1, a 2,..., a n R. [1, 41] Modules work somewhat like functions in programming languages; In the example taken from Wikipedia, we might have the production rule a(x, y) : x == 0 a(1, y + 1)b(2, 3), so that the example string a(0, 1)[b(0, 0)]a(1, 2) will become a(1, 2)b(2, 3)[b(0, 0)]a(1, 2). Parametric L-systems allow properties associated with turtle interpretations, such as line segment length and change in angle, to become part of the system itself. [3] 10

11 As 2-dimensional turtle interpretation of L-systems is possible, so is 3-D turtle interpretation. The turtle s location is represented by a point (x, y, z) R 3, and its heading is represented by a set of three mutually orthogonal vectors H (heading), L (left), and U (up). Rotations about these three vectors can be represented by 3 3 matrices. Since I took the course CSCI 383: Theory of Computation, I have been interested in systems capable of general computation, and it would be interesting to study L-systems from that angle. I briefly mentioned in the introduction how L-systems are more powerful than Chomsky grammars of the same class. I suspect that parametric context-sensitive L-systems may be as powerful as Turing machines, since non-parametric context-sensitive L-systems are already more powerful than context-sensitive grammars, which are as powerful as nondeterministic linear-bounded automata (nondeterministic Turing machines with their tape limited to the length of their input) [2, 258]. A construction that converts an arbitrary Turing machine to a parametric context-sensitive L-system (and vice versa), may be something possible to study in the future. References [1] Prusinkiewicz, Przemyslaw, and Aristid Lindenmayer. The Algorithmic Beauty of Plants. New York, NY: Springer-Verlag, Print. [2] Kozen, Dexter C. Automata and Computability. New York, NY: Springer-Verlag, Print. [3] L-system. L-system. Wikipedia: The Free Encyclopedia, 25 Feb Web. 23 Mar