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

F(8) =

49254260310842419635956203183145610297181518175722

645092459215139793457671268

F(9) =

57032537052310667848333041074211374735281465442837

91462534074054620078654283606800818374139986561628

18312245600441263643840637616695537715519251334538

3524

F(10) =

76468130255471596415502126628721272799965622845736

77558480382297701212511606356101663314925946526090

67058203469259617081728805336711057422313308364587

60151524974173668422050436187679282345568982688613

38467531695234021911130357872921130260900383280816

75334391261705569553545097889635713998326750896107

70246756

*Edited on ***March 5, 2016, 10:49 am**