We present a design technique for generating rigidly foldable quadrilateral meshes (RFQMs), taking as input four arrays of direction angles and fold angles for horizontal and vertical folds. By starting with angles, rather than vertex coordinates, and enforcing the fold-angle multiplier condition at each vertex, it is possible to achieve arbitrarily large and complex panel arrays that flex from unfolded to flatly folded with a single degree-of-freedom (DOF). Furthermore, the design technique is computationally simple, reducing for some cases to a simple linear-programming problem. The resulting mechanisms have applications in architectural facades, furniture design, and more.

## Introduction

Many techniques of origami, the art of paper-folding, have found their way into technological applications. However, many of those applications require materials that are a good deal stiffer than paper: polymers, metal, wood, and composites. Realization in such materials commonly requires the creation of regions of localized compliance, e.g., hinges, along fold lines, and between otherwise rigid panels. The need to reproduce the folding motion of the original origami—going from an unfolded or flat-folded state to a deployed state—with such stiff materials restricts the range of usable patterns to those that are *rigidly foldable*: those in which, throughout the folding motion,

planar facets remain planar and

creases and vertices remain geodesically fixed.

Consequently, the topic of rigid foldability in origami mechanisms has been of great interest for many years [1–13].

Origami models can be considered to be compliant mechanisms because their motion comes from the deflection of flexible materials [14]. Rigidly foldable origami can be modeled using the pseudo-rigid-body model concept [15] where creases are modeled as revolute joints and panels as rigid links. This results in rigid-link spatial mechanisms that can be modeled using the methods traditionally employed to model the kinematics of rigid-link mechanisms [16–19].

Major progress in the field of rigid foldability came in the 2009–2010 work of Tachi [7,9,10], who developed a theory of rigidly foldable quadrilateral meshes (RFQMs) composed of developable vertices—those whose surrounding sector angles sum to 360 deg, or, equivalently, those that unfold to a flat sheet. Notably, he identified an invariant that existed for flat-foldable degree-4 vertices; the ratio of half-angle tangents between all fold pairs was a constant, independent of the folded state. This led to the result that in any quadrilateral mesh of developable flat-foldable vertices, if there existed a single intermediate folded state, one between unfolded and flat-folded, then the entire pattern formed a single degree-of-freedom (DOF) mechanism that flexed from fully unfolded to fully flat-folded, limited only by self-intersection avoidance. Based on this idea, Tachi developed a software tool, rigidorigamisimulator [13], in which one could design rigidly foldable mechanisms (as well as nonrigidly foldable structures) by manipulating selected vertices of a general quadrilateral array subject to computer enforcement of developability and/or flat-foldability at each vertex.

The requirement of existence of some intermediate state is nontrivial, however. In a paper analyzing origami twist patterns, Evans et al. [4] showed that there were meshes consisting entirely of flat-foldable vertices for which no such intermediate state existed. We introduced the term *fold-angle multiplier* to describe the invariant ratio and showed that for many twist fold patterns, dependencies within the pattern created closed inequality loops of the form *a* > *b* > *c* > *a* among fold angles, which were unsatisfiable. That work underscored the importance of fold angles (versus vertex coordinates) in the design of developable flat-foldable RFQMs. Indeed, a complete description of the kinematics of such structures can be built just from its angles: the fold angles at the vertices and the sector angles around each degree-4 vertex (D4V).

In this paper, we present a design algorithm for developable locally flat-foldable rigidly foldable quadrilateral meshes—henceforth, DLFF-RFQMs—that is built from angles. We take as our design inputs two arrays of fold angles and direction angles that, together, fully specify a single degree-of-freedom rigidly foldable mechanism. We begin with a brief recap of the relevant kinematic relationships and then present a step-by-step design algorithm that proceeds from the angle arrays to a fully constructed mechanism. The full design algorithm requires the solution of a constrained optimization problem. We show that for rectangular crease patterns, this step reduces to a simple linear-programming problem. We show how various design goals may be incorporated naturally as additional constraints in the optimization and then present several design examples that show the diversity of possible mechanisms that can be achieved. We then close with some discussion of applications and prospects for the future.

## Background

*Fold angles* are the angles at folds, are conventionally defined as the deviation from flatness [20], and are characterized as *valley folds* for positive fold angle and *mountain folds* for negative fold angle. Figure 1 shows an example of each and the convention for how it is defined.

The kinematic relationships for a flat-foldable D4V are shown in Fig. 2. The vertex has fold angles *γ*_{1}–*γ*_{4} and sector angles *α*_{1}–*α*_{4}, where a *sector angle* is the angle between consecutive folds around a vertex.

A flexible D4V will have three fold of one mountain-valley assignment, one of the other. The two fold opposite each other with the same assignment are the *major folds*; in Fig. 2, *γ*_{2} and *γ*_{4} are the major fold angles. The two opposite folds with different assignment are the *minor folds*; in Fig. 2, *γ*_{1} and *γ*_{3} are the minor fold angles. Major fold angles are equal to each other (*γ*_{2} = *γ*_{4}); minor fold angles are equal and opposite sign (*γ*_{1} = −*γ*_{3}).

*fold-angle multiplier μ*, the ratio between adjacent fold half-angle tangents. For the configuration of Fig. 2, we define

and Eq. (3) must be satisfied for all folded states. From Eq. (2), it is clear that $|\mu 1,2|\u22651$ for all fold angles.

An equivalent formula was given by Tachi [7,10]; similar angular relationships between adjacent fold angles for developable vertices have been presented by others [22,23], and a similar relationship applies to the vertices of the nondevelopable discrete Voss surface [24]. This particular form has the desirable features of simplicity and validity for all combinations of signs of the fold angles.

*γ*

_{2}=

*γ*

_{4}, we also have that $\mu 1,4=\mu 1,2$, and so $\mu 1,4$ is also given by Eq. (4). Substituting $\alpha 1=\pi \u2212\alpha 3$ and $\alpha 2=\pi \u2212\alpha 4$ into Eq. (3) gives another form

*γ*

_{2}and

*γ*

_{4}are the major-fold angles. It is straightforward to rearrange vertex indices to obtain the equivalent ratio for

*γ*

_{1}and

*γ*

_{3}major. If we cyclically permute the indices $1\u21922,\u20092\u21923,\u20093\u21924,\u20094\u21921$, then $\mu 1,4\u2192\mu 2,1$, and its value becomes

## Quad Meshes

In a rigidly foldable quad mesh whose vertices are all developable and flat-foldable D4Vs, since the magnitude of the fold angle is constant across each vertex, the folds can be organized into continuous chains running vertically and horizontally in which the fold-angle magnitude is constant for each entire chain. However, the sign may or may not switch at any given vertex, depending on whether the chain is major or minor at that particular vertex. A chain of fold angles could be major at one vertex, minor at the next, depending on the relative magnitudes of the fold angles of the two chains intersecting at the vertex.

Because of Eqs. (3), (4), and (7), the fold angles and sector angles at a vertex cannot be chosen entirely independently. In the conventional way of looking at crease patterns, the sector angles ${\alpha i}$ are given, setting the value of $\mu i,j$; then by choosing one fold angle, Eq. (3) implicitly determines the adjacent fold angles.

However, there is another way to look at this: we could instead take the two fold angles as given. In this case, we can choose only one of the sector angles; the other three must be set to satisfy the Kawasaki–Justin condition, Eq. (1), and Eqs. (4) and (7).

*γ*

_{2}and

*γ*

_{4}major, the fold-angle multiplier $\mu 1,2$ is given by Eq. (3) and the four sector angles can be shown to be

We can use these relationships to define an entire RFQM, because they imply a directional flow of design information: we can choose design parameters along two edges of the pattern that fully define the relevant angles at those edges and then use the relationships in Eqs. (8) and (9) to propagate the fold angles and sector angles across the pattern.

Specifically, if we come in from left and bottom with two fold with angles *γ*_{1} and *γ*_{2} traveling at specified direction angles, the angle between the two fold will determine the sector angle *α*_{1}; this will, in turn, determine the other three sector angles, and thus, the direction angles and fold angles of the two outgoing folds. By selecting initial conditions of fold angle and direction angle along two sides of an RFQM, we can then propagate the fold angles and direction angles throughout the entire mesh, thereby completely determining its kinematic behavior. Furthermore, by ensuring that the flow of information is unidirectional, we can completely avoid the unsatisfiable inequality loops that arise in, for example, rigidly foldable twists [4].

Note, however, one constraint implicit in this formulation. If two adjacent folds have the same fold-angle magnitude, then we will have $|\mu 1,2|=1$, which will make one of the sector angles zero. This is not allowed; thus *at any interior vertex, no two adjacent folds can have the same fold-angle magnitude*.

## Kinematic Design

Equations (8) and (9) are the heart of the algorithm, but some care must be taken to ensure information flow directionality and to determine what quantities may be chosen and which ones are determined by equations and constraints. We take as our architecture a mesh of quadrilateral panels, with *n _{h}* panels in the

*horizontal*direction and

*n*panels in the

_{v}*vertical*direction. We index vertices, edges, and faces as shown in Fig. 3.

We partition the edges into two sets: those running predominantly horizontally (shown in gray) and those running predominantly vertically (in black). Each index pair (*i*, *j*) applies to the facet it is drawn in, the edges to left and below, and the vertex to lower left, as indicated in the figure. Note that each of the horizontal or vertical pair could be major or minor, depending on the relative fold-angle magnitudes.

With each horizontal and vertical edge, we associate *direction angles*$\varphi h,i,j$ and $\varphi v,i,j$, respectively, which are the angles with respect to the *x*-axis of each edge from one vertex to the next in the unfolded state, as illustrated in Fig. 4. Similarly, we associate fold angles $\gamma h,i,j$ and $\gamma v,i,j$ with their corresponding edges.

At each vertex, inputs come from the bottom and left; outputs are the top and right. We show the (*i*, *j*) vertex as an example, illustrated in Fig. 5.

If $|\gamma 2|>|\gamma 1|$, then *γ*_{2} and *γ*_{4} are major; Eq. (8) gives the other three sector angles and $\gamma 4=\gamma 2,\u2009\gamma 3=\u2212\gamma 1$. Otherwise, if $|\gamma 2|<|\gamma 1|$, then *γ*_{1} and *γ*_{3} are major; Eq. (9) gives the other three sector angles and $\gamma 4=\u2212\gamma 2,\u2009\gamma 3=\gamma 1$. Note that no horizontal fold-angle magnitude can be equal to any vertical fold-angle magnitude.

By following this procedure, working from the bottom upward and rightward, we can construct fold angles and direction angles for all interior creases of the crease pattern. This fully defines the kinematic behavior of the entire mechanism.

On the boundary, there is no fold angle. For simplicity and definiteness, we can set all boundary fold angles to zero. The boundary direction angles, however, have meaning and need to have values. There are two possible approaches:

Choose their values.

Leave their values as variables to be optimized.

Leaving them as values to be optimized brings up the obvious question: what are the variables to be optimized over? And another question: what are the coordinates of the vertices? These two questions are related, as it turns out, and we turn now to them both.

## Embedding

There remain several quantities in the design still to determine. In particular, we must determine the lengths of all of the creases. We introduce length variables $lh,i,j$ and $lv,i,j$ for each of the horizontal and vertical edges.

where $u\u0302(\varphi )\u2261(cos\u2009\varphi ,\u2009sin\u2009\varphi )$ is the unit vector at direction angle $\varphi $.

It is important to note that each of the ${pi,j}$ is a linear combination of the edge-length variables. Figure 6 shows schematically how the vertices are constructed relative to one another, by following the shaded lines of the spanning tree of the crease pattern.

Each of these constraint equations is also linear in the edge-length variables.

The resulting system is generally underconstrained with respect to the edge-length variables; there are $(nh)(nv+1)$ horizontal edges, $(nh+1)(nv)$ vertical edges, and $(nh)(nv)$ equality constraints, leaving $nhnv+nh+nv$ degrees-of-freedom in the system.

We also have inequality constraints. The edge lengths must be non-negative; otherwise, there would be crease lines crossing each other at places other than vertices. So we must have at the very least inequality constraints on every edge length of the form $li,j,k\u22650$.

In fact, at least some of the edge lengths must be strictly positive to prevent the entire system from collapsing to a point. We might well wish to set a minimum nonzero edge length on every edge or on some subset. If the edge length is nonzero on every edge, then it guarantees that all facets are quadrilateral and all vertices are degree-4. If we allow some edges to be zero length, it will collapse some facets to triangles (or to vanish) and merge some vertices into vertices of higher degree. This might well give useful and desirable folding patterns, and the resulting patterns will be guaranteed of at least one degree-of-freedom in their motion, but they might well have picked up additional degrees-of-freedom by the merging of vertices into vertices of higher degree.

The choice of minimum edge length and other constraints will be driven by esthetic choices, but there is one particularly simple and useful set of choices:

We set a minimum edge length of one on all edges, to ensure that all edges participate visibly in the folding mechanism.

We choose to make the paper rectangular, which thereby sets all of the boundary direction angles.

Since it is esthetically undesirable to have enormous contrast between edge lengths, we take the total of all edge lengths as the figure-of-merit to minimize.

This choice gives a system where the figure-of-merit, equality constraints, and inequality constraints are all linear in the edge-length variables. Hence, the problem reduces to a linear-programming problem, for which fast and efficient solutions are readily available.

We have constructed a Mathematica function that takes as input four angle arrays—direction angles and fold angles, along the bottom and left side—and returns a crease pattern and folded form for a rectangular-paper pattern with the specified angles.

*l*), the inputs initiating the folds that propagate roughly left-to-right will be

Each pattern is a single-DOF mechanism, so there are multiple sets of fold angles that will give the same crease pattern, but a different folded state somewhere between unfolded and flatly folded.

Any transformation of all fold angles that preserves this ratio will also preserve all sector angles and so constitutes a valid set of fold angles for the same sector angles and thus for the same crease pattern.

It is readily verified that making the substitutions $\gamma i\u2192fm(\gamma i),\gamma j\u2192fm(\gamma j)$ in Eq. (24) leaves the value of $\mu i,j$ unchanged. Thus, for any real number *m*, applying *f _{m}* to all of the fold angles of a design set will give the same crease pattern, but a different state of the folded form. Figure 8 shows four different states of the folded form of Fig. 7 for different values of

*m*.

*Miura-ori*[25] and Barreto's

*Mars*[26] (also known as Sakoda's

*Staircase*[27]), defined by angle arrays

*Mars*/

*Staircase*. Direction angles $\varphi l$ and fold angles $\gamma l$ apply to the creases incident to the left edge (going from bottom to top); angles $\varphi b$ and fold angles $\gamma b$ apply to the creases incident to the bottom edge (going from left-to-right).

*Mars*but swapping some fold-angle signs as in Eq. (28) gives a very different pattern, shown in Fig. 10

The internal fold directions are different, of course owing to how the fold-angle signs affect the sector angles of the interior vertices; the spacings between folds also differ, owing to the different influences of the minimum edge length set on all edges.

In isolation, degree-6 vertices have three degrees-of-freedom, so such a pattern is not a priori constrained to a single-DOF. However, if a degree-6 vertex is surrounded by D4Vs, as is the case in both of these mechanisms, the surroundings will constrain the vertex so that the entire mechanism is single-DOF; this is the case for both mechanisms shown in Fig. 11.

## Optimization Constraints

As long as the vertical and horizontal fold-angle set has no fold-angle magnitude in common, the procedure outlined in Sec. 5 is guaranteed to produce a kinematic set of sector angles that gives a single degree-of-freedom mechanism. However, there is no corresponding guarantee that the linear programming problem that defines the edge lengths gives a noncrossing crease pattern, i.e., a crease pattern with all-non-negative edge lengths. In fact, it is quite easy to find sets of angle values for even quite small patterns for which no solution can be found under the rectangular-paper assumption.

The reason for this is simple: once we have chosen the input angles, all of the angles in the crease pattern are fully specified, and the input choices might well have caused the quad mesh to distort so much that the boundary direction angles are constrained to ranges that don't include the values of 0 and $\pi /2$ specified earlier.

To avoid this problem, we can eliminate the rectangular-paper constraints and now allow the boundary direction angles $\varphi h,i,{0,nv+1}$ and $\varphi v,{0,nh+1},j$ to become variables in the optimization. In this case, the constraints of Eq. (20) are now not all linear in the variables, and the optimization becomes nonlinear. However, such system can still be solved with conventional nonlinear constrained optimization routines, and in practice, finding a solution that minimizes total edge length with unconstrained angles on the boundary (if one exists) is usually straightforward. (We qualify “usually” because successfully finding a solution often depends on the initial position within the search space.)

If we remove all constraints from the boundary, it is possible to have the corners entirely vanish (i.e., their incident edges become collinear). This may be avoided (for esthetic reasons) by setting additional constraints on the corner angles: for example, $\varphi v,0,0\u2212\varphi h,0,0=\pi /2$ to get a right angle at the lower left corner and similarly for the other three corners.

Most of the examples we have shown are, more or less, planar, and that is a useful property for many applications, but there is no particular restriction to planarity. Figure 14, for example, shows a rigidly foldable pattern that forms a polyhedral tube. Because the pattern is periodic, it can be extended arbitrarily in the obvious way.

Note the qualification mentioned earlier for a solution to the unconstrained-boundary case: “if it exists.” For the rectangular-boundary problem, the optimization is a linear-programming problem, and so if the solver finds no solution, we can be assured that none exists. For the unconstrained boundary, the solution is a general nonlinear constrained optimization, and so lack of finding a solution does not mean that one does not exist; it might just mean we started the search in the wrong place.

However, we can show that there are definitely combinations of angles for which there is no noncrossing solution, even in the unconstrained-boundary case. We show this by considering the form of a vertex when one of the fold angles is very much smaller than the other or very much closer to flat-folded than the other. These two configurations are illustrated in Fig. 15.

In both cases, in the limit as $\epsilon \u21920$, the vertex approaches the straight-major condition, with collinear major folds.

That means that every rectangular-boundary problem can be embedded within a larger unconstrained-boundary problem, as illustrated in Fig. 16.

In the limit as $\epsilon \u21920$, if there is no solution to the rectangular-boundary problem, then there can be no solution to the larger unconstrained-boundary problem. This establishes that there must be some particular combinations of angles for which even the unconstrained-boundary case has no noncrossing solutions.

## Fabrication

In order to verify the theory and computed models (and to show some more complex patterns than the simple illustrations of principle mentioned earlier), we have fabricated several examples from wood veneer laminate. We used *Sanfoot* wood veneer from Hokusan Ltd., Tokyo, Japan [28], and laser-scored the material, cutting through the wood (but not the backing) to produce a pattern with rigid panels joined by flexible hinges. The material is quite thin (approximately 0.23 mm), and so no thickness-accommodating techniques [2] were required: the zero-thickness model gives a very good representation of the actual behavior.

Figures 17 and 18 show two fabricated examples, crease patterns and photographs of the finished figures.

Many more pattern examples may be found in the supplementary material of Ref. [29].

## Conclusions

We have developed a design methodology for the creation of rigidly foldable quadrilateral meshes that by choosing as inputs the fold angles and direction angles along two sides of the array is guaranteed to produce a single-DOF mechanism that flexes smoothly from unfolded to flat-folded, with the range of motion limited only by self-intersection and the crease patterns limited by the possibility of self-crossing faces.

There is particular application for the construction of decorative architectural features, facades, and design elements. We illustrate the possibilities in our examples created from folded wood veneer. This technique allows the creation of deeply incised complex patterns with minimal material and wastage; realizing such forms by, e.g., milling would be extremely challenging.

Because such patterns move kinematically, they may be used in applications that undergo repeated motion from stowed to deployed, including arrays, shelters, and adaptive architecture to provide dynamic shade and/or rain protection.

We note that the single-DOF mechanism makes the assembly of one of these patterns a bit delicate, since every crease within the pattern must fold at once (albeit at varying rates). Each vertex is individually in a singular state at flatness; there are four (or more) possible mountain-valley assignments, and once a vertex has started to collapse with one assignment, it will resist flipping to a different assignment. In practice, a good way to collapse such a pattern is to apply compression forces around the four sides, then carefully “pop” each vertex to its intended mountain-valley assignment. Once all vertices are initiated “going the right direction,” the entire pattern will smoothly fold together.

For hand-folding, this behavior presents a challenge. For production fabrication, the single-DOF motion could be taken advantage of. By creating a fixed custom jig to initiate the individual vertices into their proper directions, the entire pattern could then be assembled with relatively simple compression forces, rather than requiring individual actuators on each and every fold.

We have implemented the algorithm in the Mathematica environment; the code, including code for all figures presented in this paper, many more computed examples, and score patterns for the examples presented herein, is available in the supplemental material of Ref. [29]. The algorithm presented here is simple enough that it could readily be incorporated into mechanical engineering and/or architectural design tools, e.g., grasshopper/rhino.

Since every possible DLFF-RFQM of developable locally flat-foldable vertices can be described in this framework, this methodology is guaranteed to give them all, allowing systematic exploration of configuration space.

We note, though, that there is no guarantee that any *particular* set of angles ${\varphi l,\varphi b,\gamma l,\gamma b}$ will give rise to a nonself-crossing crease pattern. Indeed, as we saw, if we impose the rectangular constraint, one can readily find angle sets for which only self-crossing crease patterns exist. If we relax the rectangular-paper constraint, making the equation set nonlinear, there may well be nonself-crossing solutions, but finding them often depends on the initial conditions of the numerical search, and, as we have seen, there will still be some sets of angles for which no nonself-crossing crease pattern exists.

As we build up a pattern from a set of input angle arrays, the fold lines propagate rightward and upward, but they change direction at each vertex, and because of the complex dependence of outgoing direction angle upon incoming fold angle and direction angle, it can be difficult to predict the overall shape of a pattern, even qualitatively, without carrying out the calculation. We have found, though, that an effective design strategy is to focus on developing small “building blocks” of creases—*tiles*, as described in Ref. [20]—that can then be combined by matching fold angles and directions into arbitrarily extensible arrays.

One interesting question is: how many topologically distinct DLFF-RFQMs are there for given (*n _{h}*,

*n*), where the topology is characterized by the mountain-valley assignments of the creases? The problem of counting mountain-valley assignments can be quite complex: see, e.g., Ginepro and Hull [30] on counting mountain-valley assignments in

_{v}*Miura-ori*patterns and related problems cited therein. The problem of counting mountain-valley assignments for DLFF-RFQMs is more tractable; we have given a solution in Appendix B.

Adopting the topology of a quadrilateral mesh is convenient for indexing and describing the topology of the planar graph that is the mesh. However, our approach could readily be generalized to arbitrary networks of crossing chains of folds incorporating triangular and/or higher-order polygons. Dealing with the complex interplay between the mesh topology (determining which chain intersects which other chain, and where) and the sector angle dependence on input fold angles seems nontrivial but does suggest that there are further avenues to pursue within the framework outlined here.

## Funding Data

National Science Foundation and Air Force Office of Scientific Research (Grant Nos. EFRI-ODISSEI-1240441, EFRI-ODISSEI-1332249, EFRI-ODISSEI-1332271, and EFRI-ODISSEI-1240417).

### Appendix A: Construction of the Folded Form

The algorithm presented in the main body of this paper provides a rigidly foldable crease pattern. In order to complete the design algorithm (including applying constraints to the folded form, such as the coplanar-facet constraint illustrated in Fig. 13), we need expressions for the vertex coordinates of the folded form in terms of the optimization variables. We provide these here. A complete design code for both crease pattern and folded form is given in the supplemental materials of Ref. [29].

The folded-form vertices can be built up by following a spanning tree on the facets, similarly to how we built the vertex coordinates of the crease pattern. However, in order to keep the symbolic expressions for vertex coordinates tractable, we need to be careful about the order in which we build up the three-dimensional form.

The first quantities to build are the direction vectors for the creases and the surface normals of the facets. In two-dimensional, the direction vectors were simply given by $u\u0302(\varphi i,j,k)$. In three-dimensional, they will be unit three-vectors, as will be the surface normal vectors. We denote by $dh,i,j$ and $dv,i,j$ the edge direction vectors and denote by $ui,j$ the facet normal vectors.

We introduce the matrix rotation $R(\theta ,a)$ as the 3 × 3 matrix that rotates a vector through angle *θ* about axis $a$.

If one keeps track of the variables through all of those (or allows a symbolic manipulation program like *Mathematica* to do the bookkeeping), it is possible to use these expressions to build constraints on the folded form, like the coplanar back-plane example shown in Fig. 13.

### Appendix B: Counting Mountain-Valley Assignments

Here we count the number of topologically distinct mountain-valley assignments for a DLFF-RFQM with flat-foldable vertices.

We note that the assignment of fold angles $\gamma h,0,j$ and $\gamma v,i,0$ fully determines the mountain-valley assignment via two steps:

At vertex (

*i*,*j*), which fold-angle magnitude is greater determines whether the vertex is major-horizontal or major-vertical.Once the major direction is determined for all vertices, the signs of all fold angles in both vertical and horizontal chains are uniquely determined by the major direction at each vertex and the signs of the fold angles at left and bottom.

Thus, the number of distinct mountain-valley assignments is the product of the number of distinct major-direction assignments times the number of distinct sign assignments along the left and bottom. Since there are $nv\u22121$ and $nh\u22121$ folds to be assigned, respectively, those last two quantities are, respectively, $2nv\u22121and\u20092nh\u22121.$

To compute the number of distinct major-direction assignments, we construct a graph whose vertices represent the fold-angle magnitudes for the horizontal and vertical chains and that contains an edge for each interior vertex (*i*, *j*). Clearly, this graph is the *complete bipartite graph* [31], conventionally denoted by *K*(*n*, *k*), with in our case $n=nh\u22121,k=nv\u22121$. An example is illustrated in Fig. 19.

A major-direction assignment of a DLFF-RFQM corresponds to an orientation of this graph, assigning the edge $\gamma h,0,j\u2192\gamma v,i,0$ if the vertex is major-horizontal and $\gamma h,0,j\u2190\gamma v,i,0$ if it is major-vertical.

Since the major-direction assignment of the DLFF-RFQM comes from the total ordering of the fold-angle magnitudes, it follows that the only possible orientations of *K*(*n*, *k*) that give rise to DLFF-RFQMs are those that are *sortable*, i.e., those in which the vertex fold-angle magnitudes can be ordered consistently with the edge orientations. A digraph is sortable if and only if it contains no cycles.

Thus, the topologically distinct DLFF-RFQM major-direction assignments correspond one-to-one with those orientations of the complete bipartite graph that are acylic, and so the number of major-fold assignments is the number of acyclic orientations out of the $2(nh\u22121)(nv\u22121)$ possible orientations of $K(nh\u22121,nv\u22121)$.

Table 1 lists the first several values for combinations of *n _{h}* and

*n*.

_{v}