## Abstract

This study aimed to develop a method to construct tensegrity structures from elementary cells, defined as structures consisting of only one bar connected with a few strings. Comparison of various elementary cells leads to the further selection of the so-called ‘Z-shaped’ cell, which contains one bar and three interconnected strings, as the elementary module to assemble the Z-based spatial tensegrity structures. The graph theory is utilized to analyse the topology of strings required to construct this type of tensegrity structures. It is shown that ‘a string net can be used to construct a Z-based tensegrity structure if and only if its topology is a simple and bridgeless cubic graph’. Once the topology of strings has been determined, one can easily design the associated tensegrity structure by adding a deterministic number of bars. Two schemes are suggested for this design strategy. One is to enumerate all possible topologies of Z-based tensegrity for a specified number of bars or cells, and the other is to determine the tensegrity structure from a vertex-truncated polyhedron. The method developed in this paper allows us to construct various types of novel tensegrity structures.

## 1. Introduction

The term ‘tensegrity’ was coined from the words ‘tensile’ and ‘integrity’ by Fuller (1962). In his patent, tensegrity was described as ‘Islands of compression inside an ocean of tension’. Later, Pugh (1976) proposed a widely accepted definition: ‘A tensegrity system is established when a set of discontinuous compression components interacts with a set of continuous tensile components to define a stable volume in space’. In practice, tensegrity structures are usually modelled as a set of weightless discontinuous bars (or struts) and continuous strings (or cables) connected by frictionless ball joints. The bars can withstand both compression and tension, while the strings can only carry tensile forces. Both bars and strings are pre-stressed and subjected to an axial load (Juan & Tur 2008). Over the last few decades, tensegrity structures have attracted considerable attention from a number of fields, such as architecture (Fu 2005), mathematics (Connelly & Back 1998), materials science (Luo & Bewley 2005), and biology (Ingber 1993, 1997).

Various types of tensegrity structures have been constructed using different methods. Most of these structures are of simple shapes and relatively small scales. Two typical early examples are two-dimensional X-shaped tensegrity (Snelson 1965) and triplex cylindrical tensegrity (Emmerich 1965). It would seem natural to regard these simple structures as elementary building modules for more complex tensegrity structures. Along this line of development, a number of methods have been proposed, which can be divided into the following three classes (Motro 2006). One class has been referred to as the node-on-node methods, which simply join the nodes of two cells together. Using such methods, for instance, Wang (1998*a*,*b*) constructed reciprocal prism and crystal-cell pyramid tensegrity structures. Motro (2006) designed a double-layer grid by assembling quadruplex cylindrical tensegrity modules, and Skelton (2002) presented a new tensegrity framework. This class of methods often produces bar–bar connections in the constructed structures that, strictly speaking, do not fall within the well-accepted Pugh’s definition of tensegrity. The second class is the node-on-cable methods, which need to break strings in one cell in order to form joint nodes of other cells. Hanaor & Liao (1991) adopted this approach to design double-layer domes assembled from triplex cylindrical tensegrity modules. The structures obtained from this class of methods fit Pugh’s definition, but so far only very limited types of tensegrity structures have been achieved. The third class of tensegrity design methods, referred to as cable-on-cable, binds two cables of neighbouring cells by adding a new node. The structures created by the cable-on-cable methods are not self-equilibrated in most cases and often need additional supports to maintain equilibrium. This disadvantage limits the application of the cable-on-cable methods only to a few special cases.

In the existing methods, simple self-equilibrated tensegrity structures such as triplex and quadruplex tensegrity prisms are usually selected as the elementary cells. As a result, the module shape in the assembled tensegrity structures is relatively rigid and only limited types of structures can be designed.

It thus seems that more universal and effective design methods are still desired for tensegrity structures. To this end, here we develop a new approach to assembling elementary cells into complex tensegrity structures that exactly comply with Pugh’s definition of tensegrity. In contrast to the existing methods, we choose the elementary cell to be a very simple Z-shaped structure containing only three strings and one bar. This method allows us to construct tensegrity structures of different shapes and relatively larger scales, and the configuration of final structures can be easily controlled and modulated by varying the original length of the strings and bars.

The outline of the paper is as follows. In §2, we will establish a set of basic rules to define elementary cells with only one bar and explain why we choose the Z-shaped cell as the elementary building module. In §3, we will use the graph theory to discuss the conditions for designing the topology of Z-based tensegrity structures. In §4, a universal design scheme of Z-based tensegrity structures will be established. In §5, an alternative approach, referred to as the polyhedral truncation scheme, will be developed. Several novel tensegrity structures will be provided in §§3 to 5 in order to illustrate the capability of the proposed approach.

## 2. Elementary cells

As discussed above, there exist a number of methods to assemble tensegrity structures based on elementary cells. For example, the triplex and quadruplex tensegrity prisms have often been selected as the elementary cells (Hanaor & Liao 1991; Motro 2006). A triplex tensegrity prism has three bars and nine strings, and a quadruplex tensegrity prism contains four bars and 12 strings. On the other hand, owing to their structural rigidity, these cells can only be used to assemble a few limited types of tensegrity structures. The goal of the present study is to establish a more flexible method to assemble tensegrity structures based on much simpler elementary cells containing only one bar. In contrast to the existing methods, the elementary cells adopted here are not complete tensegrity structures by themselves but they can be used to construct almost all types of tensegrity structures.

In defining the elementary cells, we will follow Pugh’s definition of tensegrity in that no connection is allowed between two bars. We will consider only those tensegrity structures in which each node has one and only one bar. The elementary cell adopted will consist of one bar and a few strings. In such a design approach, the number of elementary cells, *c*, will always be equal to the total number of bars, *b*, in a structure. As each bar has two nodes, the total number of nodes, *n*, is then twice *c*, i.e.
2.1

Assuming each node in the structure is shared by two elementary cells, we have
2.2
where *n*_{c} denotes the number of nodes in each cell and 〈*n*_{c}〉 is the expectation of *n*_{c}. It follows from equations (2.1) and (2.2) that 〈*n*_{c}〉=4. If a tensegrity structure is assembled from elementary cells with the same topology, then there should be four nodes in each cell, i.e. *n*_{c}=4.

Figure 1 lists all of the 10 possible topology graphs of elementary cells containing one bar and four nodes. We classify them into four groups according to the number of strings. The type-0 cell has five strings, and it can be considered as the basis for other cells. By removing one, two or three strings from the type-0 cell, we obtain elementary cells of the other nine types.

The elementary cells in figure 1 can be used to assemble almost all types of tensegrity structures. For example, the expandable octahedral, cylindrical and truncated regular tetrahedral tensegrity structures in figure 2*a*–*c* can be assembled from type-1, type-4 and type-3 cells, respectively, while planar tensegrity structures such as those shown in figure 2*d* can be constructed from the type-7 cell.

In the sequel, we will select the type-3 cell, referred to as ‘Z-shaped cell’ for its shape, as the main elementary cell to construct tensegrity structures. The reason for this selection is as follow. Firstly, if a node in a tensegrity structure has only two strings and one bar connected, force balance would require that they must lie in the same plane and the corresponding structure will be planar. Therefore, in a three-dimensional tensegrity structure, there should be at least three strings connected to a node (Motro 2006), i.e.
2.3
where *s*_{n} denotes the number of strings connected to each node. As each string in the constructed structure has two nodes, it follows from equations (2.1) and (2.3) that the total number of strings must satisfy
2.4
If no string is shared by two cells, the number of strings, *s*_{c}, in each cell of a spatial tensegrity structure should satisfy
2.5
The cells of types 7–9 in figure 1 contain only two strings each and cannot be used to construct a three-dimensional tensegrity structure. Secondly, adding strings to a stable tensegrity structure will not make it unstable, while removing strings is likely to lead to instability. Therefore, we focus on tensegrity structures in which the ratio between the numbers of strings and bars is as small as possible. Therefore, the cells of types 0–2 in figure 1, which contain four or five strings, will not be considered further in this study. Thirdly, among the cells of types 3–6, each of which contains three strings, the type-3 or Z-shaped cell can be made a pre-stressed and self-equilibrated one-dimensional structure, while the other three types cannot. This means that it should be easier to design a structure under pre-stress stability (Connelly & Whiteley 1996) based on the Z-shaped cell than on the other three types. Therefore, we will focus on the tensegrity structures assembled from the Z-shaped cell. The obtained assemblies will be referred to as the Z-based tensegrity.

## 3. Topology of Z-based tensegrity

### (a) Graph theory and basic idea of topology design

Topology determination is the first and an important step to design tensegrity structures. In this study, we will determine the topology of a Z-based tensegrity in two steps. The first step is to specify the topology of strings, and the second is to add bars into the string network. Provided that the process of adding bars is achievable for the specified topology of strings, one can readily obtain the topology of a Z-based tensegrity. From equations (2.4) and (2.5), it is known that each node in a Z-based tensegrity must be connected by three strings, i.e. *s*_{n}=3. In the terminology of the graph theory, the topology of the strings is said to be a cubic graph, also called a 3-regular graph.

It should be noted that there are a large number of cubic graphs. The following questions then arise: can all the cubic graphs be used to construct Z-based tensegrity; and if not, what are the conditions for a cubic graph to be selected?

As the three strings in a Z-shaped cell are linked end to end, their topology constitutes a path including three edges according to the graph theory. The two end vertices of the string path also correspond to the two nodes of the bar in the same cell. Therefore, once a 3-path decomposition of the cubic graph is admitted, one can easily add the bars into the topology. Here, we quote a pertinent theorem proved by Heinrich *et al*. (1999).

### Theorem

*Let G be a simple connected 3m-regular graph, which, when m is odd, has no cut edge. Then G admits a balanced 3-path decomposition.*

In the case of *m*=1, this theorem is reduced to the following proposition: ‘Every simple bridgeless cubic graph G admits a balanced 3-path decomposition’.

Here, balanced path decomposition means that ‘each vertex of *G* is an end vertex of *s* paths of the decomposition for some fixed *s*’ (Heinrich *et al*. 1999). It is evident that *s* can only be equal to 1 for the 3-path decomposition of a cubic graph. From the viewpoint of a tensegrity structure, this ensures that there is no connection between bars. The balanced decomposition also excludes the situation where the two end vertices of a path coincide. This means that the two nodes of an added bar must be different or, in other words, no bar of zero length can exist in a tensegrity structure. Such a structure perfectly matches the tensegrity definition. Therefore, the above proposition provides a sufficient condition for the cubic graphs, which can be used as the string topology of a Z-based tensegrity. Furthermore, we can prove that the restrictions of the cubic graph in the proposition are also necessary for designing a practical tensegrity structure. Firstly, the topology of strings in the tensegrity structures under study has neither multiple edges nor self-loops or, in the terminology of the graph theory, the corresponding cubic graph is always simple. Secondly, the topology of strings in the tensegrity structures of interest must also be bridgeless. In the graph theory, a bridge is defined as an edge (or a string in the tensegrity structure under study) whose removal will disconnect the graph into two separate parts. Thus, a structure with a ‘bridge’ is unstable and impractical.

From the above proposition and discussions, we have the following corollary for Z-based tensegrity structures:

### Corollary

*A Z-based tensegrity structure can be constructed by adding bars to a string net if and only if the topology of strings is a simple and bridgeless cubic graph.*

Based on this corollary, one can construct the topology of the structure from a cubic graph. Once the topology is determined, the next step is to set proper original lengths and stiffness of the bars and strings before using a form-finding procedure. As the two parameters are not independent for the form-finding of a tensegrity, for the sake of simplicity, we set the stiffness of all elements as unity. Generally, to keep a tensegrity structure in a state of pre-stress stability, its strings are all in tension and bars in compression (Connelly & Whiteley 1996). An obvious way to achieve such a pre-stressed state is to set the bar length in each cell to be longer than the total length of its three strings.

As the final step of design, the equilibrium configuration of the tensegrity structure is found by using the Monte Carlo form-finding (MCFF) method recently developed by the authors (Li *et al*. submitted). The MCFF method is based on an accept-or-reject scheme. In each iteration step, one generates a trial configuration through random sampling and then compares it with the configuration of the previous step. If the trial configuration has lower energy than the previous one, it will be accepted; otherwise it will be rejected. The essence of the MCFF procedure is to search for the equilibrium state of a tensegrity structure that minimizes the system energy. The iteration will be terminated after the equilibrium state has been reached.

### (b) Examples

To illustrate some applications of the proposed topology design method, a number of simple examples will be given in the following. It can be shown that all polyhedra with three edges connected at each node satisfy the topology requirements in the corollary. This has inspired us to construct Z-based tensegrity structures following the topology of a polyhedron.

For string nets with a regular cubic graph topology, we can manually add the needed bars for tensegrity. For instance, take the pentagonal prism as the topology of a string net, as shown in figure 3*a*. The topology after adding bars is shown in figure 3*b*, and the final form-finding result of the tensegrity using the MCFF method is shown in figure 3*c*. The obtained structure is named as prismatic tensegrity in Zhang *et al.* (2009), which is also a special case of traditional cylindrical tensegrity consisting of five bars (Tibert & Pellegrino 2003). As all the prisms are cubic graphs, we can construct many other cylindrical tensegrity structures in a similar way.

Next, we consider a more interesting example, in which the topology of strings is a sphericon-like (Stewart 1999) polyhedron assembled from two half-prisms, as shown in figure 4*a*. The corresponding topology after adding bars and form-finding are given in figure 4*b,c*, respectively. This structure resembles a configuration of two half-cylindrical tensegrities fused together.

Another cubic graph family is the hexagonal mesh shown in figure 5*a*. For the hexagonal topology, there are two different modes of adding bars, as coloured by cyan and magenta in figure 5*a*, respectively. Such hexagonal configuration has been used by Motro (2006) to classify and define the geodesic ‘Z’ tensegrity system, which always has a spherical shape. Here, we draw inspirations from nanostructures such as Bucky balls (figure 5*b*) and capped carbon nanotubes (figure 6*a*). After adding bars and form-finding, we can design not only spherical structures resembling a Bucky ball but also tubular structures like a carbon nanotube, as shown in figures 5*c* and 6*b*, respectively.

## 4. Direct enumeration scheme

Based on our analysis of the graph theory, we have developed a new route to designing the topology of tensegrity structures from the Z-shaped elementary cell. The topology of strings is first determined from cubic graphs, and then the bars are added manually. Some novel tensegrity forms have been obtained by this method. For most cubic graph topologies of strings, however, the manual addition of bars is not straightforward, especially for tensegrity structures of relatively large scales. Therefore, we will propose a canonical method based on the direct enumeration of all the cell nodes of a Z-based tensegrity structure.

A Z-based tensegrity consisting of *b* elementary cells should have *b* bars, 2*b* nodes and 3*b* strings. Let the 2*b* nodes of the *b* cells be consecutively numbered from 1 to 2*b*. As each Z-shaped cell has four nodes, we define four column vectors **t**_{j}(*j*=1,2,3,4) to locate the nodal numbers in the entire structure. The *i*th component of **t**_{j} is the *j*th nodal number of the *i*th cell. Thus, the topology of the tensegrity is represented by the following *b*×4 matrix of nodal numbers:
4.1
The four integers in the *i*th row of **T** correspond to the nodal numbers of the *i*th cell. As a consequence, the connectivity of the bars and strings can be clearly expressed by
4.2
respectively. We define the global connectivity matrix as
4.3
According to the definition of tensegrity (Pugh 1976), the structure shall have no node shared by two bars. Therefore, it is convenient to set the connectivity matrix of the bars as
4.4
As each node is shared by two cells, every nodal number appears twice in **T**. This means that the other two column vectors **t**_{2} and **t**_{3} in **T** also contain all the nodal numbers from 1 to 2*b*. It can be seen that the list is a permutation of {1,2,…,2*b*}, which should satisfy the following two conditions in order to ensure that the topology of strings is a simple graph:

(i) In each row of

**T**, all the nodal numbers must be different;(ii) In the matrix

**S**, any two rows must have at least one different number.

Condition (i) excludes the existence of string loops or zero-length bars and condition (ii) rules out the possibility that there may exist multiple strings between any two nodes. For programming, one just needs to test all the possible permutations of {1,2,…,2*b*} by conditions (i) and (ii). The matrix **T**, which passed the test, will represent a topology of possible tensegrity structures.

Using the above scheme, one can study the topology of Z-based tensegrity structures with a given number of bars. When *b*=2, for example, **T** has the following two forms satisfying conditions (i) and (ii):
4.5
In fact, the two solutions are isomorphic, with their topology being given in figure 7*a*. The string topology in figure 7*a* is the unique 4-node cubic graph, which is named the complete graph *K*_{4} (Diestel 2006). The form-finding result is similar to the X-frame tensegrity, as shown in figure 7*b*, in which the two bars coincide with two of the strings.

If we wish to exclude any coincidence of strings and bars, the above condition (ii) should be modified into the following stricter one:

(ii') In the matrix

**C**, any two rows must have at least one different number.

In this case, we find that when the total bar number *b*=3, there is only one possible topology for Z-based tensegrity. The form-finding calculation leads to the well-known triplex tensegrity prism, as shown in figure 8*a*. Its topology can be expressed by the following **T** matrix:
4.6

When *b*=4, there are five possible topologies of the strings. To satisfy conditions (i) and (ii′), three equilibrium configurations can be achieved by the MCFF method, as shown in figure 8*b*–*d*. The structure in figure 8*b* has a cubic shape, in which all the strings lie on the edges, and the four bars along the diagonals intersect at the centre point of the cube. This is a special form of the quadruplex prismatic tensegrity structures. In the terminology of Zhang *et al.* (2009), the topology of this structure corresponds to . Evidently, it is different from the conventional quadruplex (or half-cuboctahedron) tensegrity , which does not belong to the family of Z-based structures. The two structures in figure 8*c* and *d* have the same string topology but two different ways of adding bars. The **T** matrices of the structures in figure 8*b*–*d* are
4.7
respectively.

With increasing *b*, the number of possible topologies grows very rapidly. For a specified *b*, one can in principle enumerate all possible topologies of Z-based tensegrity structures, by replacing the list with all the possible permutations of {1,2,…,2*b*}, followed by elimination of configurations that are isomorphic or violate condition (i) or (ii′).

## 5. Polyhedral truncation scheme

### (a) Methodology

The direct enumeration scheme in §4 allows us to find the topologies of all the Z-based tensegrity structures for a specified number of cells, and it is also useful to study the topology of relatively small-scale tensegrity structures. To design a tensegrity structure of a larger scale, however, the direct enumeration scheme would become time consuming. For a large value of *b*, the number of possible topologies can be huge and most of them lead to impractical configurations that are either irregular or have intersecting bars. Therefore, for designing Z-based tensegrity structures of a larger scale, further simplification of the assembly procedure is necessary. To this end, we propose a much simpler scheme, referred to as the polyhedral truncation scheme, based on the graph analysis in §3. In this scheme, we will use a polyhedron to determine the approximate configuration of the tensegrity structure in design and obtain the topology of strings by its vertex truncation. The polyhedron is truncated by cutting all its original vertices and creating a new polygonal facet around each vertex. No matter how many edges are connected at a vertex in the original polyhedron, the truncation will make each new vertex having just three edges connected. That is, the new polyhedron is guaranteed to be an appropriate cubic graph for the design of Z-based tensegrity structures. For instance, figure 9*a* shows a pyramid, which is originally not a cubic graph because the vertex G has four edges. However, the polyhedron, after truncation, has evidently become a cubic graph with three edges at each vertex.

The truncation method is not only convenient in constructing cubic graphs to be used as the topology of strings but also in the addition of bars. We still take the pyramid in figure 9*a* as an example. The red lines denote the new edges generated owing to the truncation, named the ‘truncating-edge strings’; and the magenta lines denote the remaining segment of the edges in the original pyramid, called the ‘remaining-edge strings’.

Once the topology of strings has been obtained, we can add the bars in a truncated polyhedron according to the following two rules:

(i) each cell contains only one remaining-edge string, and this string must be in the middle of the two others;

(ii) the two nodes of each bar must be on two different polygon faces.

The first rule determines the middle two column vectors **t**_{2} and **t**_{3} of **T** in equation (4.1), and the second rule makes the tensegrity configuration have a shape like the truncated polyhedron. In addition, rule (ii) reduces the options of each row in **T** from four to two. For instance, there are originally four possible ways (DE, CF, CE and DF) to add a bar that creates a cell containing the remaining-edge string AB in figure 9*a*, but rule (ii) precludes the two ways of CE and DF for the requirement of topology. The remaining two choices (DE and CF) correspond to two tensegrity structures of different (right- and left-handed) chiralities.

If one adds a bar between D and E as the blue line in figure 9*a*, the cell containing the next remaining-edge string CI will be uniquely determined. One can only add a bar between A and J because another path DK will cause the connection of two bars at node D. The topology of this structure can be uniquely determined by repeating the same procedure. The final form-finding result of the truncated pyramid tensegrity structure is shown in figure 9*b*.

### (b) Examples

Comparing figure 9*a,b*, it is seen that the equilibrium configuration of the obtained tensegrity is similar to the shape of a truncated pyramid. Therefore, this method makes it convenient to design tensegrity structures from specific polyhedra. To construct a tensegrity structure with a required configuration, one just needs to choose a polyhedron with a similar shape and to perform the above-described manipulation in a canonical manner.

Using the polyhedral truncation scheme, for instance, we have constructed tensegrity structures having the approximate shapes of a truncated triangular prism and a truncated regular octahedron from the corresponding polyhedra. The form-finding results are shown in figure 10*a,b*, respectively. Similarly, the structure in figure 5*c* can also be achieved easily by this truncation scheme from an icosahedron.

It is worth pointing out that the truncation method is applicable not only for convex polyhedra, but one can also use this scheme to design tensegrity structures of many other different shapes, e.g. concave polyhedron shapes. As an example, figure 11*a* shows a concave polyhedron, which then leads to a heart-shaped tensegrity, as shown in figure 11*b*.

Furthermore, we can also extend the above truncation method for spatial tensegrity structures by truncating a planar lattice and then rolling it up. figure 12 shows an example of how to truncate a planar lattice. By truncating all the intersecting points of the planar triangular mesh in figure 12*a*, a hexagon mesh is obtained, as shown in figure 12*b*. Following the two rules in §5*a*, the two modes of adding bars in figure 5*a* can be implemented. Such graphene-like planar structure can be rolled up into tensegrity structures having the shape of a capped carbon nanotube (Reich *et al*. 2005), as shown in figure 6*b*.

As another example of planner lattices, figure 13*a* shows a square mesh. Similarly, the truncation of this lattice and the addition of bars are shown in figure 13*b,c*, respectively, which leads to some new types of tensegrity, e.g. the structure of a quadrangular prism shape in figure 13*d*.

The above examples demonstrate that the truncation method provides an efficient and programmable approach to designing tensegrity structures.

## 6. Conclusions

In the present paper, we have demonstrated a promising approach to constructing three-dimensional tensegrity structures from elementary cells. Among all the basic cells with only one bar, we have chosen to focus in this paper upon the Z-shaped cell to assemble the so-called Z-based tensegrity structures, which are in strict compliance with the definition of tensegrity. Our analysis based on the graph theory of topology shows that Z-based tensegrity structures can be constructed by adding a pre-determined number of bars into string nets with a simple bridgeless cubic graph topology.

Starting from the above basic idea, we have developed two different schemes to assemble Z-based tensegrity structures. One is the direct enumeration scheme, which systematically searches for all possible topologies for Z-based tensegrity for a given number of cells and then filters out the unwanted structures among the possible solutions. The other, named the polyhedral truncation scheme, provides a more efficient and fast way for the practical design of tensegrity structures. To construct a tensegrity structure with a required configuration, one just selects a polyhedron with a similar shape, truncates all its vertices and then adds the bars in a canonical manner. Both schemes are easily programmable, and have generated a number of novel tensegrity structures. Finally, it is worth mentioning that, among all types of spatial tensegrity structures, the Z-based structures have the smallest ratio between the numbers of strings and bars, and can be utilized to further construct many other types of stable structures by adding additional strings.

## Acknowledgements

The support from the National Natural Science Foundation of China (grant nos. 10525210 and 10732050) and 973 Program (2010CB631005) is acknowledged.

## Footnotes

- Received May 13, 2009.
- Accepted September 1, 2009.

- © 2009 The Royal Society