What started fairly simply has grown into something which can be quite complicated. It can be taken as it is, comprising a reasonably complete theory of natural flexagons. On the other hand, several assumptions were made along the way which could be reconsidered. For example, the primitive polygon stack was gotten by fanfolding, but that is not the only way a string of polygons can be doubled up. Another assumption was that consecutive, adjoining edges of the polygon were used as hinges, so that none were skipped.

What still remains constant is that one single polygon, regular or not, is used in the construction, and that where polygons are joined, it is done by reflection in the edge where they are joined. That ensures that the stack really is a stack; that is, all the edges are parallel and there is a common margin for the whole cylinder. Later it may be opened up to get parallel stacks, or several blades in a leafed structure or whatever, but that comes later on.

It also remains constant that the flexagon is a frieze, namely that it is an unbranched string of polygons joined along their edges (not just by vertices, for example), although it may meander around and even cross over itself due to the angles between the hinges. So the only real question remaining is how it is to be folded from a frieze into a stack. After that, its folding properties in three dimensions have to be examined, following which it may be seen that some friezes work and others don't. But the first thing to be done is to figure out how to describe the layout of the frieze and how it has been folded.

Since the frieze is laid out by joining polygons, the only variation which has to be described is the order in which to take the edges as hinges; so far the order has been assumed to be consecutive, the only variation being in whether to run around clockwise or counterclockwise, and then only because the sense is reversed when the polygon is turned over as it might have been in the recursive step.

Some people like to lay down the polygon and think of external compass directions, such as North, South, East, West for square flexagons. But internal directions can be used; orient the polygon, choose a positive sense and mark that on the polygon along the rim so it doesn't matter whether it has been turned over or not. Then `+`, `++`, ... , `-`, `-`, ... can be used to say how many edges to skip over and in which direction. If there get to be too many plusses, say n+ as in 3+. We have already used this notation in the three-line polygon list; where the choices in the first line were confined to `+` or `-`. So that notation will be kept.

Where the polygon is located on the stack is the other thing which has to be specified. The first polygon goes on top. The second polygon will go somewhere lower down, exactly where will only be known when after the folding has been done. But when it is finished, it is possible to count down the stack and see where it ended up. In a fanfold, it will be the second polygon, turned over. But even in flexagons built recursively from fanfolds, some scrolling will take place, so there is no guarantee of where the second polygon will sit in the stack. Nor for the third and so on, but they have to sit somewhere. No two sit in the same place, and there are no repetitions untill all have been used.

That is the information stored in the second and third lines of the polygon table. Two lines were used to recognize that the polygon has two sides, only one is visible on top but both have colors (or better, numbers) The principal numbers alternate between the two lines and their counterpart is gotten by adding 1 (signifying ``next color to be seen'' but neither ``next on the frieze'' nor ``next on the stack'' unless it happens that way).

Well, this correspondence between two lists is called a permutation, and that is what decides that the polygon on the frieze sits in the site in the stack, upside down or not. Altogether there is enough information to describe the flexagon, and with adequate care, to build it. The recursive process which has been described up to now is just one way of building a flexagon, with the advantage that it is quite clear where everything goes without first having to put the polygons in place and then having to peer into the flexagon to decide just what ended up where. Or conversely, having to stick your fingers or twigs or something between polygons to save place for one which is going to be inserted later on.

The main difference in this general point of view and the graphs heretofore described is that the graph isn't necessarily the same one. Now the preferred graph describes the permutation. For the fractal polygon stack kind of flexagon, that is the sequence of labels you get by following the Tukey triangles (in the flexagon paper this is called the Tuckerman Traverse) and so the permutation graph and the one already worked out are the same. But skipping edges and skipping position in the stack need a reinterpretation of the graph, which is probably best omitted. Rather, use the three-rowed polygon list directly.

To see how this works, think of a flexagon made up from two squares (and then continued into more segments if necessary). A basic requirement for all flexagons is that the initial edge and the final edge be parallel, which means that the total sum of angles is 360 degrees (remember the dictum, the sum of the angles is 360 degrees?). If the angle in a square flexagon is 90 degrees, that means `+ + + +` or else `++ ++`, or the analogue with `-`'s. But we have just two squares so it is `++` and they are joined at opposite edges. You don't get anything at all!

That isn't totally true; a string of squares joined at opposite edges is something you can buy at the post office, namely a roll of stamps. One of the things mathematicians have studied is, how many ways can they be folded into a stack? The result is called a ``Catalan Number'' and you can look it up on the Internet with Google. But that isn't something that you would want to call a flexagon.

The next possibility is to take three squares, for which the only frieze summing up to a rotation is `+ ++ +`, as in the following figure:

As usual an additional square has been included as a tab for pasting. The heavy lines (with ='s) should match when joining two of these friezes and then connecting their ends.

The flexagon actually works, and can be recognized as a pair of barroom hinges opening in opposite directions and placed one above the other. This was pretty hard to get using natural flexagons.

Thinking of four squares, there are combinations like `(+ + + +)`, `(+ ++ - -)`, `(+ - ++ -)`, etc. Of course, `++` is the same as `-`, implying opposite edges, and a sum of 0 is as good as 360 degrees.

Trying `(++ ++ ++ ++)` comes back to stamp folding, so we ignore it. As for the permutations, it is agreed that 1 matches 1, but 2 can become 2, 3, or 4 which gives six possibilities, and then 3 can become one of the two leftovers. That leaves no choice for the last, but otherwise there are twelve possibilitiers. To be checked, one by one, against three or more possible friezes! Quite a bit of work.

A while ago we worked out a few of these combinations. The permutation (1 2 3 4) is fanfolding, the sequence (1 2 4 3) fans two and scrolls two; or in other words the fourth square is placed on top of the third square, rather than under it. The following table shows the results:

sign sequence | ||||

permutation | + + + + |
+ + - - |
+ ++ - - |
+ ++ - - |

(1 2 3 4) | natural | flaps | flap-scroll | Good f'gon |

(1 2 4 3) | tubulates | tubulating | scrolling | crossed |

As the variety of adjectives indicates, we have a collection of mixed results. Tubulating refers to the fact that the flexagon may not respond to the normal flexing movements in some positions, because the hinges are not at right angles to one another, but rather parallel at opposite ends just as happens in the stamp folding exercise. But the combination makes a square cylinder - the ``tube'' - which can be opened and closed with the internal hinges now on the far ends, and the reverse for what were formerly widely separated. After making this change it may be possible to continue flexing in the accustomed manner, revealling new faces. This switchover is called tubulating, and is a requirement in some flexagons for viewing all the faces.

Careful examination of the flexagon shows that the switch from fan to scroll while changing the permutation was responsible. That means that there are indeed other primitive flexagons besides the fanfolded ones, even though they arise from exactly the same frieze. Just the scheme of folding changes.

Other parts of the table show what happens when squares are joined on opposite edges into a strip rather than by adjacent edges into a zigzag. One of the most common results is to get back to stamp folding, which is ambiguous from the point of flexagons. That is, a flexagon should be held in place by the angles between fold axes except when everything has been carefully aligned while flexing. But the strips often have to be positioned by hand and carefully maneuvered to avoid disturbing the layout. So while they are technically good flexagons, they are usually excluded from systematic lists.

Another consequence of folding willy-nilly is that the frieze may be doubled into a hard knot which cannot be undone. So in contrast to the natural flexagons wherein the recursive process assures that everything will work out, the general designs have to be checked. What that means is really that some more complicated rules need to be derived for taking them into the category of flexagons. Or that the properties of recursion based on another primitive cannot be anticipated, allowing the other primitive to be used interchangeably with the fanfold.

It would appear that fairly random things can be flexagons, and it could be there that a systematic exposition of the theory ends. Looking through the books we have accumulated and offerings on the Internet, and of course such journal articles as exist, only flexagons based on equilateral triangles have gotten any mathematical treatment at all. There are several designs based on squares which don't go much beyond showing some examples. No doubt there are knowledgeable people here and there, but if they haven't tried to disseminate their knowledge is some publicly accessible form, there is no way to know what it is.

On the other hand, the recognition that fractal polygon stacks comprise an extensive and well structured assortment of flexagons, and that still other classes can be found could be taken as a good stopping point. One of these other classes consists of the tubulating flexagons; those for which more complicated spatial arrangements exist but which still have phases which lie flat in a plane. We have not looked too far into the degree to which the fractal philosophy could be applied to them, but something is surely possible. Meanwhile, there are some simple families such as scrolls which can be examined with little effort.

Just setting down permutation and turning sequences gives an enormous number of possibilities, not all of which fold up neatly and deserve to be called flexagons. Part of that neatness is that there shouldn't be loose groups which can move back and forth without special positioning of the rest of the flexagon. Another would be that the frieze should'nt be tied into a knot which can't be undone by rotations, but only by sliding the frieze into position. The recursive construction assures the behavior of the flexagon, but that is just one way of making one.

To better visualize the partial list showing some four-square flexagons, the following diagrams repeat the table but includes the friezes.

The same frieze, because of the sequence + + + + for both examples, folds two ways according to the two different permutations. The first is the primitive flexagon made from squares, the second will not fold in a cycle but given parallel hinges at the extreme ends of a pair of squares will make a cylinder which can be folded back along the complementary hinges and opened out to lie flat. That is the operation of tubulation, following which different colored faces have become visible. Both flexing and tubulating are needed to see all the faces.

The sign sequence `+ + - -` typically leads to a frieze in which the squares move back and forth connected to form a snake. When used as the basis of a flexagon as short as this the normal form sprouts flaps whereas the tubular form tubulates. The sequence `+ - + -` would generate a spiral, which is not shown.

The normal form of this long strip leads to flaps, which is to be expected because of the hinges on opposite sides of the squares rather than on adjacent sides where they cab block movement. But in the tubular form, where a little bit of scrolling alreasdy exists, the final result is a pair of contrarotating scrolls. The combination is bulky and only allows running through a sequence in which all hinges are parallel, but it works out. Indeed, it is the prototype for general scrolls.

The polygon list for a general scroll would read

+ | ++ | ++ | ++ | ++ | ++ | ++ | ... | + |

1 | . | 2 | . | 3 | . | 4 | ... | 1 |

. | n | . | n-1 | . | n-2 | . | ... | . |

Depending on whether n is even or odd, the sequence has two endings. If n is even, there is an even number of ++'s, the last entry in the list would be -, giving an overall sum of zero. When n is odd, the odd number of ++'s has to be balanced by an initial and final + to again get a zero sum. This says that one frieze of n squares will connect to the next at the top edge of the last square or at the bottom edge according to parity. That turns out to be just what is needed to make a scroll.

Surprisingly, the normal form (identity permutation) with the turning sequence `+ ++ - -` generates a good flexagon although its layout is slightly curious. The tubular form is also interesting, although not quite a flexagon. Laid out in planar form with two squares at each corner, folding along a horizontal axis runs through three colors while from the same position and folding by the vertical axis runs through three other colors (two of which are the same in both positions). That is why the flexagon was described as ``crossed.''

So there it is, ``A Quick Flexagon Survey.''

The construction of flexagons as fractal polygon stacks gives a nice theory with beautiful ramifications, but just making up a stack without any particular order seems to produce vastly more flexagons. The problem lies in deciding which stacks will fold nicely, which is readily apparent with the fractal process based on fanfolded cycles of regular polygons. There must be other starting points, but it seems that nobody has carried flexagon studies that far.

With squares, building arbitrarily long scrolls has already been mentioned, although there are practical limits due to the thickness of the folds if half a dozen or more squares are included in the base stack. But in looking at that list of some flexagons made with four squares, there is a vestige of a braided stack. They are made from long strips just like the scrolls, but the strip is folded at a right angle in the middle and the two halves fanfolded back and forth across each other to form a braid.

Actually, if just two strips are crossed and folded this way, and the loose ends joined, but for the two strips separately, something which Tony Conrad called a bregdoid results; they have interesting folding properties of their own, but they remain largely unexplored. However, having fanfolded a single bent strip, there are two loose ends which can be connected to a similar stack to get an interesting flexagon which will not fold indefinitely. Nevertheless, turning it over after each flex, the braid can be transferred from one diagonal of the square planar form to the other. As such, very much longer strips can be folded, although there comes a point at which nothing particularly new is gained through doing so.

Both this form and the scrolling form can be created with the natural flexagons; the difference is that they can be made with a single thickness of paper from which every face can be exposed whereas the other version uses more complicated folds and some faces are never exposed although it is theoretically possible to do so. Again, paper thickness is the governing factor. We once built up a fanfolding triangle flexagon with several hundred faces, just to prove that it could be done.

Here are the first few flexagons in this series:

The pattern repeats by going on to use more squares, so it will not be written out further here. The differences obviously arise from the different ways the tails of the braids have to be joined, and how to write the sequences beginning with 1 each time. between even and odd total lengths, there may be an odd square left over and the other braid will have to be turned over to make the join. But then the middle will have to be described differently, and the choice of `+` or `-` in the middle shows that the two braids have to be oriented differently there too.

Allowing for the four cases, the general pattern is more or less

+ | ++ | ++ | ++ | ... | ++ | ++ | ++ | + |

1 | . | 4 | . | ... | . | 5 | .. | 1 |

2 | 2 | . | 6 | ... | 7 | . | 3 | . |

The `++`'s grow on the right, and the 1 after the vertical bar (signifying whether or not to turn the second copy over to join it), alternates between top and bottom. If the proper number of positions (n, that is) has been provided in the list, working in from the ends will decide the middle. Altogether there are four cases, not only as n is odd or even but on its remainder modulo 4. Don't forget the rule to add 1 to the number on the opposite side to fill in the single dots.

The resulting flexagons are nice enough that they are worth adding to the list of easily made examples. Looking at them for a little while shows that scrolling can be combined with braiding (or fanfolding) to get mixed results; indeed inadvertently moving the `+`'s or `++`'s around in the construction list can already make the change for you.