In origami there are two ways of folding a piece of paper. The usual way is to fold the paper upwards and if unfolded the crease is called a valley fold and from the side it looks like this: \/ If the paper is folded backward instead the crease is called a mountain fold and looks like this: /\.
If you take a strip of paper and fold it in half twice (left over right) and then unfold it without flipping you will get a figure that looks something like this from the side:
Which consists of the following sequence of folds:
/\ \/ \/
Describe the sequence of folds if the original strip of paper had been folded over 10 times and then unfolded.
Using 'A' as a mounatin fold and 'V' as a valley fold, it is easy to build representations of successive folds by applying an algorithm of taking a previous level of folds, reversing and inverting it, and creating a new string from the inverse, an V and the prior string. This is discussed in earlier coments.
Staring with just the lone valley fold, the algorithm produces:
F(1) = V
F(2) = A + V + V = AVV
F(3) = AAV + V + AVV = AAVVAVV
F(4) = AAVAAVV + V + AAVVAVV = AAVAAVVVAAVVAVV
F(5) = AAVAAVVAAAVVAVV + V + AAVAAVVVAAVVAVV = AAVAAVVAAAVVAVVVAAVAAVVVAAVVAVV
Due to the nature of the algorithm the first character (starting with F(2)) is A and the middle and last characters are V.
But there is another similarity: the two halves being spliced are nearly identical, differing only in the middle part - an A in the middle of the left and a V in the middle of the right. To prove this, let X be any string and Y be its mirrored reversal (If X=AAAVVVAV then Y=AVAAAVVV). (The mirrored reversal is a symmetric operation, so if X->Y then Y->X.) Assume F(n) = XVY. Then the mirrored reverse of F(n) is XAY. This makes F(n+1) = XAYVXVY. From this it is easy to see that the two halves are nearly identical in the way indicated previously.
Then an alternate, equivalent algorithm can be made. Given F(n), invert its center character and call the result F'(n). Then F(n+1) = F'(n),V,F(n) concatenated in that order.
Convert the strings to binary using A=1 and V=0 to get a sequence (converted to base 10): 0, 4, 100, 27748, 1826909284, ... Then a recursive rule for the sequence can be written as F(n) = F(n-1)*(2^(2^(n-1))+1) + 2^(3*2^(n-2)-1). The binary expansion of the terms in the sequence describe the sequence of mountain (1 bit) and valley (0 bit) folds after n folds have been made. The sequence continues as
F(2) = 4
F(3) = 100
F(4) = 27748
F(5) = 1826909284
F(6) = 7846656366854040676
F(7) = 144745261873314177466380711909411548260
Edited on March 5, 2016, 10:49 am