## Abstract

Disordered structures such as liquids and glasses, grains and foams, galaxies, etc. are often represented as polyhedral tilings. Characterizing the associated polyhedral tiling is a promising strategy to understand the disordered structure. However, since a variety of polyhedra are arranged in complex ways, it is challenging to describe what polyhedra are tiled in what way. Here, to solve this problem, we create the theory of how the polyhedra are tiled. We first formulate an algorithm to convert a polyhedron into a codeword that instructs how to construct the polyhedron from its building-block polygons. By generalizing the method to polyhedral tilings, we describe the arrangements of polyhedra. Our theory allows us to characterize polyhedral tilings, and thereby paves the way to study from short- to long-range order of disordered structures in a systematic way.

## Introduction

Disordered structures are often represented as polyhedral tilings^{1,2,3,4,5,6,7,8,9,10,11}. For example, in studying the atomic structures of amorphous materials, the space can be divided into the so-called Voronoi polyhedra, where each polyhedron encloses its associated atom^{1,2,3,4,5,6,7,8}. The shape of the polyhedron relates to how the associated atom is surrounded by its neighbouring atoms. The short-range order of a disordered structure can be thus characterized by what polyhedra constitute its associated polyhedral tiling, while the long-range order by how the polyhedra are arranged. So far, some attempts have been made to classify individual polyhedra^{1,11,12,13,14,15,16} and periodic tilings for crystals^{17,18}. However, there have been no methods to describe what polyhedra are tiled in what way. If we could describe the arrangements of polyhedra, our understanding of the disordered structures would be deepened.

In this work, we create the theory of how the polyhedra are tiled. For this purpose, we use the hierarchy of structures of polytopes^{19,20}: a polyhedron (3-polytope) is a tiling by polygons (2-polytopes), a polychoron (4-polytope) is a tiling by polyhedra, and so on. We first formulate a code for polyhedra (*p*_{3}-code), and then generalize it to polychora. The code for polychora (*p*_{4}-code) allows us to describe what polyhedra are tiled in what way.

## Results

### Polygon-sequence codeword

A polyhedron can be regarded as a tiling by polygons of the surface of a three-dimensional object that is topologically the same as a three-dimensional sphere. According to the idea developed by L. Euler, A. M. Legendre, F. Möbius, and P. R. Cromwell^{19}, we assume that polygons are glued such that (1) any pair of polygons meet only at their sides or corners and that (2) each side of each polygon meets exactly one other polygon along an edge. In this picture, the vertex is a point on the polyhedron at which the corners of polygons meet (Supplementary Fig. S1a), and we say that the corners *contribute* to the vertex. We also say that a polygon (side) contributes to a vertex if one of its corners (endpoints) contributes to the vertex. Similarly, the edge is a line segment on the polyhedron along which the sides of polygons meet (Supplementary Fig. S1b). The interior area of a polygon is the face of the polyhedron.

We first deal with simple polyhedra, where every vertex is degree three. Here, the degree of a vertex is the number of edges connected to that vertex^{21}. Afterwards, the method will be generalized to non-simple ones. We formulate the *p*_{3}-code in such a way that the codeword of a polyhedron (simply, *p*_{3}) instructs how to construct it from its building-block polygons. For this purpose, we combine a *polygon-sequence codeword* (*ps*_{2}) and a *side-pairing codeword* (*sp*) as *p*_{3} = *ps*_{2};*sp*, where “;” is a separator.

The *ps*_{2}-codeword is denoted as

Here, *p*_{2}(*i*) is the number of sides on the polygon *i,* where *i* is the identification number (ID). *F* is the number of faces on the polyhedron. Generating *ps*_{2} thus reduces to assigning polygon IDs. To visually distinguish already-encoded polygons from to-be-encoded ones, we assume that all polygons are coloured at first, and make each polygon transparent when encoded. We call a side of a transparent polygon glued to a coloured one a *dangling side*. To identify each side, we introduce the side-ID *i*_{j}. Here, the side *i*_{j} means the *j*th side of the polygon *i*, and the side-ID *i*_{j} represents an integer: *i*_{j} = *j* + . We also assign corner IDs so that the endpoints of the side *i*_{j} are the corners *i*_{j + 1} and *i*_{j} for 1 ≤ *j* < *p*_{2}(*i*) (Fig. 1a). The smallest-ID dangling side (*s-side*) plays a key role in encoding. The *ps*_{2}-codeword is generated as follows (Fig. 1b,c):

(a) Choose a side as the initial side, and the polygon 1 is the one having that side.

(b) Assign IDs (1

_{1}, 1_{2}, 1_{3}, ···, ) to the sides of the polygon 1 from the initial side in a clockwise (CW) direction.(c) Make the polygon 1 transparent except for the corners and sides.

(a) The next polygon

*i*(2 ≤*i*≤*F*) is the coloured one glued to the s-side.(b) Assign IDs (

*i*_{1},*i*_{2},*i*_{3}, ···, ) to the sides of the polygon*i*from the side glued to the s-side in a CW direction.(c) Make the polygon

*i*transparent except for the corners and sides.

(a) Repeat the procedure 2 until all polygons get transparent.

For latter convenience in formulating the *p*_{4}-code, we assign edge IDs as follows. First we tentatively assign the smaller side ID to the edge, and then relabel the IDs so that the edge *i* is the one with the *i*th smallest tentative ID as illustrated in Fig. 1d. We also assign vertex IDs in a similar manner. First we tentatively assign the smallest corner ID to the vertex, and then relabel the IDs. Since the properties of simple polyhedra are not assumed, the algorithm for generating *ps*_{2} can be used to assign face, edge and vertex IDs not only to simple polyhedra, but also to non-simple ones.

We note that *p*_{2}(*F* − 1) and *p*_{2}(*F*) can be deduced from *p*_{2}(1) *p*_{2}(2) *p*_{2}(3) ··· *p*_{2}(*F* −2) (see Supplementary Note and Supplementary Fig. S2). However, we purposely admit the small redundancy in *ps*_{2} to explicitly express all information about the polygons of the polyhedron.

### Tentative side-pairing codeword

To formulate *sp* and the decoding algorithm, we first introduce the *zeroth tentative side-pairing codeword* (*tsp*^{(0)}). We then formulate an algorithm to recover the original polyhedron from *ps*_{2}*;tsp*^{(0)}. Finally, we remove redundancy in *tsp*^{(0)} step-by-step to obtain *sp*.

We first introduce a *plot* as follows. A plot consists of a single dangling side or a chain of dangling sides. Here, two dangling sides are considered to be *chained* when they contribute to the same vertex contributed by two transparent polygons. Let *x* be the smallest side ID of a plot. We define the ID of that plot as *x* (Fig. 2a). We call the smallest-ID plot the *s-plot*. Note that all the sides of each plot are glued to the same coloured polygon.

If we encode a polyhedron twice, we know all the IDs of the polygons and sides from the beginning in the second time of encoding. When the polygon (*i* − 1) gets transparent, the coloured polygon *i* is glued to the s-side, so that the s-plot is glued to the polygon *i*. For example, in encoding the polyhedron shown in Fig. 2b, the polygon 2 in *P*_{1} is glued to the s-plot 1_{1} (Fig. 2c). Here, *P*_{i} is the object obtained when the polygon *i* gets transparent. In *P*_{7} (Fig. 2d), the polygon 8 is glued to the plot 5_{6} in addition to the s-plot 3_{4}. We call such an additional plot an *a-plot*. The smallest-ID side of the a-plot 5_{6}, which is the side 5_{6}, is glued to the side 8_{5}. We call such a pair an *a-pair* 8_{5}5_{6}. The sides 10_{4} and 5_{4} also form the a-pair 10_{4}5_{4} (Fig. 2e).

By collecting the a-pairs, we define *tsp*^{(0)} as

Here, the sides *y*_{a}(*i*) and *x*_{a}(*i*) form the a-pair *y*_{a}(*i*)*x*_{a}(*i*), where *y*_{a}(*i*) > *x*_{a}(*i*), and *y*_{a}(*i*) < *y*_{a}(*i* + 1). *N*_{a} is the number of a-pairs. For example, *tsp*^{(0)} of the polyhedron shown in Fig. 2b is 8_{5}5_{6}10_{4}5_{4}.

### Decoding algorithm

To formulate a decoding algorithm, we consider the sequence *D*_{1} *D*_{2} *D*_{3} ··· *D*_{F}, where *D*_{i} is the partial polyhedron obtained when the polygon *i* is decoded. For the encoding process, we also consider the sequence *E*_{1} *E*_{2} *E*_{3} ··· *E*_{F}. Here, *E*_{i} is the partial polyhedron obtained by removing the coloured polygons from *P*_{i} (Fig. 3a,b). For *D*_{i} and *E*_{i}, if a side is not glued to the other polygon, we call it a dangling side. To define the plot, we consider a pair of two dangling sides to be chained if they contribute to the same vertex contributed by two polygons.

We formulate an algorithm to recover the original polyhedron from *ps*_{2};*tsp*^{(0)} so as to satisfy *D*_{i} = *E*_{i} at any *i*. If we assign side IDs (1_{1}, 1_{2}, 1_{3}, ···, ) to a *p*_{2}(1)-gon, then the resultant object *D*_{1} is identical with *E*_{1}. Assume *D*_{i − 1} = *E*_{i − 1} for 2 ≤ *i* ≤ *F*. To construct *D*_{i} (=*E*_{i}) from *D*_{i − 1} and *ps*_{2};*tsp*^{(0)}, we introduce a rectification mechanism as follows. Since *D*_{i} is the partial polyhedron of a simple polyhedron, *D*_{i} must not have any degree-four vertex contributed by three polygons. We call such a vertex an *illegal vertex* (*i-vertex*). However, we allow intermediate products to transiently have i-vertices. When an i-vertex is generated, we rectify it by gluing together the two dangling sides contributing to it (Fig. 3c). Using the rectification mechanism, *D*_{i} can be constructed as follows. We first glue the side *i*_{1} of the polygon *i* to the s-side of *D*_{i − 1} (Fig. 3d,e). This is because *E*_{i} consists of the polygon *i* and *E*_{i − 1} in such a way that the side *i*_{1} of the polygon *i* is glued to the s-side of *E*_{i − 1}. In addition, if *y*_{a}(*n*) (1 ≤ *n* ≤ *N*_{a}) is the side ID of the polygon *i*, then we glue the side *y*_{a}(*n*) to the side *x*_{a}(*n*) of *D*_{i − 1} (Fig. 3f) –for the polygon *i* in *E*_{i} is glued to not only the s-plot, but also the a-plot *x*_{a}(*n*) of *E*_{i − 1} (Fig. 3b). If the product has i-vertices, we rectify them so that all the sides of the s-plot and a-plots get glued to the polygon *i* properly to satisfy *D*_{i} = *E*_{i} (Fig. 3g,h).

To summarize, the original polyhedron can be recovered from *ps*_{2};*tsp*^{(0)} as follows (Fig. 1e):

(a) The polygon 1 is a

*p*_{2}(1)-gon.(b) Assign IDs (1

_{1}, 1_{2}, 1_{3}, ···, ) to its sides in a CW direction. The resultant object is*D*_{1}.

(a) The next polygon

*i*(2 ≤*i*≤*F*) is a*p*_{2}(*i*)-gon.(b) Assign IDs (

*i*_{1},*i*_{2},*i*_{3}, ···, ) to its sides in a CW direction.(c) Glue the side

*i*_{1}of the polygon*i*to the s-side of*D*_{i − 1}.(d) If

*y*_{a}(*n*) (1 ≤*n*≤*N*_{a}) is the side ID of the polygon*i*, then glue the side*y*_{a}(*n*) to the side*x*_{a}(*n*) of*D*_{i − 1}.(e) If i-vertices are generated, then rectify them, and repeat this procedure until no i-vertices remain. The resultant object is

*D*_{i}.

(a) Repeat the procedure 2 until all polygons are placed.

### Side-pairing codeword

In decoding *ps*_{2};*tsp*^{(0)}, *D*_{i} = *E*_{i} at any *i*. However, what we need is just *D*_{F} = *E*_{F}. By allowing *D*_{i} ≠ *E*_{i} for 1 ≤ *i* ≤ *F* − 1, we can make the more compact *sp* as described below.

We remove redundancy in *tsp*^{(0)} step-by-step. To examine *y*_{a}(*N*_{a})*x*_{a}(*N*_{a}) for necessity, we consider the *first test codeword* denoted as

which is obtained by stripping *y*_{a}(*N*_{a})*x*_{a}(*N*_{a}) off from *tsp*^{(0)}. Then we attempt to decode *ps*_{2};*test*^{(1)}. When the polygon having the side *y*_{a}(*N*_{a}) is decoded, we will fail to glue the sides *y*_{a}(*N*_{a}) and *x*_{a}(*N*_{a}) together, because the a-pair *y*_{a}(*N*_{a})*x*_{a}(*N*_{a}) is missing in *test*^{(1)}. However, we can proceed decoding. If the missing a-pair is cured and the original polyhedron is successfully reproduced in the subsequent decoding process, then we call the a-pair the *curable a-pair*. Otherwise, we call it the *non-curable a-pair*. If the a-pair is curable, then we can remove *y*_{a}(*N*_{a})*x*_{a}(*N*_{a}) from *tsp*^{(0)}. We therefore set the first tentative side-pairing codeword as *tsp*^{(1)} = *test*^{(1)}. On the other hand, if the a-pair is non-curable, then *tsp*^{(1)} = *tsp*^{(0)}.

To examine *y*_{a}(*N*_{a}+1 − *i*)*x*_{a}(*N*_{a }+ 1 − *i*) (2 ≤ *i* ≤ *N*_{a}) for curability, we consider the *i*th test codeword *test*^{(i)}, which is obtained by stripping *y*_{a}(*N*_{a} + 1 − *i*)*x*_{a}(*N*_{a} + 1 − *i*) off from *tsp*^{(i − 1)}. Then we attempt to decode *ps*_{2};*test*^{(i)}. If the a-pair is curable, then *tsp*^{(i)} = *test*^{(i)}, otherwise, *tsp*^{(i)} = *tsp*^{(i − 1)}.

We repeat the above-mentioned procedure, and is what we call *sp*. For example, *tsp*^{(0)} of the polyhedron shown in Fig. 2b is 8_{5}5_{6}10_{4}5_{4}. The a-pair 10_{4}5_{4} is non-curable (Supplementary Fig. S3a), while the a-pair 8_{5}5_{6} is curable (Supplementary Fig. S3b). As a result, *sp* = 10_{4}5_{4}. Since the polyhedron is encoded as 458585574755433: 10_{4}5_{4}, we call it a 458585574755433;10_{4}5_{4}-polyhedron, or a 4(58)^{2}5^{2}7475^{2}43^{2};10_{4}5_{4}-polyhedron for short.

### Representative codeword

Our encoding starts with choosing an initial side. A different initial side for the same polyhedron may give a different *p*_{3}-codeword. There are 2*E* possible initial sides for a polyhedron. Here, *E* is the number of edges on the polyhedron. We also examine the mirror-image polyhedron, which gives additional 2*E* possibilities. A maximum of 4*E* different codewords can be obtained from a polyhedron and its mirror image. To determine the representative one, we introduce the lexicographical number Lex(*p*_{3}). Given that *ps*_{2} and *sp* can be read as positive *F*- and 2*N*_{na}-digit integers, we define Lex(*p*_{3}) as the concatenation of the two numbers. Here, *N*_{na} is the number of non-curable a-pairs. We use the codeword with the smallest Lex(*p*_{3}) as the representative one.

### Non-simple polyhedron

On the analogy of the *n*-regular graph^{21}, we call the polyhedron whose vertices are all degree *n* the *n*-regular polyhedron. 3-regular polyhedra are simple, while, for *n* > 3, *n*-regular polyhedra are non-simple. In encoding [decoding], if we regard that two dangling sides are chained when they contribute to the same vertex contributed by (*n *− 1) transparent polygons [polygons] and modify an i-vertex to be a vertex contributed by a pair of two dangling sides and *n* transparent polygons [polygons], our *p*_{3}-code is straightforwardly applicable to *n*-regular polyhedra. For example, the octahedron is encoded as “4-regular 3^{8}”. The icosahedron is “5-regular 3^{20}”. However, if a non-simple polyhedron is non-regular, this method cannot be used. To deal with all non-simple polyhedra, we formulate a method that uses a one-to-one correspondence between a non-simple polyhedron and its associated simple one as described below.

Any non-simple polyhedron can be transformed into its associated simple polyhedron by cutting every vertex of degree *d* (>3) and replacing it with a *d*-gonal cross section^{22}. For example, a non-simple pentagonal pyramid can be transformed into a pentagonal prism by cutting the apex (Fig. 4a,b). By marking the cross sections, a one-to-one correspondence can be established between any non-simple polyhedron and its associated simple one. Using the one-to-one correspondence, we encode a non-simple polyhedron. Here, we modify the s-side to be the smallest-ID dangling side in real polygons (not cross sections) so that the face, edge, and vertex IDs of a non-simple polyhedron determined from its associated simple polyhedron using an algorithm described below conform to those determined directly from itself using the algorithm described above. The *p*_{3}-codeword of a non-simple polyhedron is generated as follows:

Choose a side of a non-simple polyhedron as an initial side.

Construct its associated simple polyhedron by cutting every vertex of degree

*d*(>3) and replacing it with a*d*-gonal cross section.Encode the associated simple polyhedron from the initial side corresponding to the one determined in the procedure 1.

Put a dot on

*p*_{2}(*i*) if the polygon*i*is the cross section; for example, a codeword for the pentagonal pyramid is , or for short, indicating that the polygon 7 is a cross section.The edge and face IDs can be assigned as illustrated in Fig. 4c.

Since *ps*_{2} contains dots, it is not a number. We therefore define Lex(*ps*_{2}) as the concatenation of two numbers *ps*_{2}^{(1)} and *ps*_{2}^{(2)}. Here, *ps*_{2}^{(1)} is a number obtained from *ps*_{2} by replacing every number without a dot to 0 and then by removing all dots, while *ps*_{2}^{(2)} is obtained by removing all dots from *ps*_{2}. For example, Lex is the concatenation of 0000005 and 5444445, namely, 00000055444445.

Note that, if a vertex is concave, cutting the vertex may not be well defined. However, by assuming that a polyhedron is flexible, we can inflate it so that a concave vertex becomes a convex one. Then we can cut the vertex.

Decoding is achieved easily. We first construct the associated simple polyhedron, and then shrink the cutting sections to the vertices.

The duality of polyhedra can be used to make a codeword more compact. Every polyhedron has its associated dual, which is constructed as follows^{21}:

Draw a vertex

*v*_{i}^{*}of the dual polyhedron on each face*f*_{i}of the original polyhedron.Draw an edge

*e*_{ij}^{*}of the dual, if the faces*f*_{i}and*f*_{j}share an edge*e*, to connect the vertices*v*_{i}^{*}and*v*_{j}^{*}such that*e*_{ij}^{*}crosses*e*, but does not cross the other edges.

There is a one-to-one correspondence between the original polyhedron and its dual. For example, the dual of an octahedron is a hexahedron (Fig. 5a,b). Reversely, the dual of a hexahedron is an octahedron (Fig. 5b). A *p*_{3}-codeword for the octahedron is 66()^{6}, while a *p*_{3}-codeword for the hexahedron is 4^{6}. Using the duality, we encode the octahedron as ^{★}4^{6}. Here, “^{★}” indicates that the octahedron is the dual of the 4^{6}-polyhedron. We define Lex (^{★}4^{6}) as the concatenation of Lex (^{★}), which we define as 1, and Lex(4^{6}). Therefore, Lex (^{★}4^{6}) is 1444444. On the other hand, Lex(66()^{6}) is 0040404040404066464646464646. Since Lex (^{★}4^{6}) is the smallest, the representative *p*_{3} for the octahedron is ^{★}4^{6}, which is more compact than 66()^{6}. We also note that the hexahedron can be encoded as ^{★}66()^{6}, but it is not the representative codeword. For reference, the representative *p*_{3}-codewords for the tetrahedron, hexahedron, octahedron, dodecahedron, and icosahedron are 3^{4}, 4^{6}, ^{★}4^{6}, 5^{12}, and ^{★}5^{12}, respectively.

Consider that we calculate *p*_{3} for a polyhedron by encoding its dual for a given initial side of the original polyhedron. To determine the initial side for encoding the dual, we use the one-to-one correspondence between the original polyhedron and its dual. For example, in encoding an octahedron shown in Fig. 5, when we choose the side *cb* of the polygon *cbf* as the initial side, the edge *cb* is the edge 1 and the vertex *c* is the vertex 1. The edge and vertex are mapped to the edge *hl* and face *hlmi* of the dual. Using this relation, we choose the initial side for encoding the dual so that 1s are assigned to the edge *hl* and face *hlmi*. Thus, the initial side is determined to be the side *hl* of the polygon *hlmi*.

Our *p*_{3}-code is more robust and efficient than the previous methods for polyhedra^{1,11,12,13,14,15,16} (see Supplementary Note). However, what is really stupendous is that only our theory can be generalized to polyhedral tilings as described below.

### Code for polychora

We regard a polychoron as a tiling by polyhedra of the surface of a four-dimensional object that is topologically the same as a four-dimensional sphere. We assume that polyhedra are glued together such that (1) any pair of polyhedra meet only at their faces, edges, or vertices and that (2) each face of each polyhedron meets exactly one other polyhedron along a ridge. The 0-face, peak, and ridge are a point, line segment, and area on the polychoron, where the vertices, edges, and faces of polyhedra meet, respectively (Supplementary Fig. S1c–e). The interior space of a polyhedron is the cell of the polychoron.

We first deal with polychora whose peaks are all contributed by three polyhedra. Afterwards, the method will be generalized to polychora in general. The *p*_{4}-codeword consists of a *polyhedron-sequence* codeword (*ps*_{3}) and a *face-pairing* codeword (*fp*), and is denoted as *p*_{4} = *ps*_{3};*fp*.

The *ps*_{3}-codeword is denoted as

where *C* is the number of cells on the polychoron, and *p*_{3}(*i*) is the *p*_{3}-codeword for the polyhedron *i*. To assign IDs to the polyhedra, we use edge (face) IDs *i*_{j}. Here, the edge (face) *i*_{j} is the *j*th edge (face) of the polyhedron *i*. In encoding, each polyhedron is coloured at first, but gets transparent when encoded. We call a face of a transparent polyhedron glued to a coloured one a *dangling face*. The smallest-ID dangling face (*s-face*) plays a key role in encoding. The *ps*_{3}-codeword is generated as follows (Fig. 6 and Supplementary Fig. S4):

(a) Choose a face of a polyhedron and an edge of that face as the initial face and edge, respectively; the polyhedron 1 is the one having the initial face.

(b) Determine

*p*_{3}(1) by encoding the polyhedron 1 in such a way that the face 1_{1}(edge 1_{1}) becomes the initial face (edge).(c) Make the polyhedron 1 transparent except for the vertices and edges.

(a) The next polyhedron

*i*(2 ≤*i*≤*C*) is the coloured one glued to the s-face.(b) Determine

*p*_{3}(*i*) by encoding the polyhedron*i*in such a way that the face*i*_{1}(edge*i*_{1}) is glued to the s-face (the smallest-ID edge of the s-face).(c) Make the polyhedron

*i*transparent except for the vertices and edges.

(a) Repeat the procedure 2 until all polyhedra get transparent.

As with the case of polyhedra, this method can be used to assign cell, ridge, peak, and 0-face IDs to polychora in general.

To define *zeroth tentative face-pairing codeword tfp*^{(0)}, we explain plots for polychora. If a pair of two dangling faces contribute to a peak contributed by two transparent polyhedra, the dangling faces are considered to be *chained*. A single dangling face or chained dangling faces form a plot; the plot here is a two-dimensional object. We assign plot IDs so that the smallest-ID face of the plot *x* is the face *x*. If the polyhedron *i* in *P*_{i − 1} is glued to plots other than the s-plot, we call them *a-plots*. By the a-pair *wzv*, we mean that the face *w* (of the polyhedron *i*) is glued to the face *v* of the a-plot *v* in such a way that the edge *z* (of the face *w*) is glued to the smallest-ID edge of the face *v.* By collecting the a-pairs, *tfp*^{(0)} is denoted as

Here, *w*_{a}(*i*) > *v*_{a}(*i*) and *w*_{a}(*i*) < *w*_{a}(*i* + 1).

In decoding, by a *dangling face*, we mean a face that is not glued to the other polyhedron. If a pair of dangling faces contribute to a peak that is also contributed by three polyhedra, we call that peak an *illegal peak* (*i-peak*). The i-peak can be rectified by gluing together the two dangling faces contributing to it. The original polychoron can be recovered from its *ps*_{3};*tfp*^{(0)} as follows (Supplementary Figs S5 to S7):

1.

(a) Decode

*p*_{3}(1) to obtain the polyhedron 1, assigning face and edge IDs.

2.

(a) Decode

*p*_{3}(*i*) to obtain the next polyhedron*i*(2 ≤*i*≤*C*), assigning face and edge IDs.(b) Glue the face

*i*_{1}of the polyhedron*i*to the s-face of*D*_{i−1}in such a way that the edge*i*_{1}is glued to the smallest-ID edge of the s-face.(c) If

*w*_{a}(*n*) (1 ≤*n*≤*N*_{a}) is the face ID of the polyhedron*i*, then glue the face*w*_{a}(*n*) to the face*v*_{a}(*n*) of*D*_{i−1}in such a way that the edge*z*_{a}(*n*) is glued to the smallest-ID edge of the face*v*_{a}(*n*).(d) If i-peaks are generated, then rectify them, and repeat this procedure until no i-peaks remain.

3.

(a) Repeat the procedure 2 until all polyhedra are placed.

By an similar argument for *sp*, the redundancy in *tfp*^{(0)} can be removed step-by-step with generating *tfp*^{(1)}, *tfp*^{(2)}, *tfp*^{(3)}, ···, and *tfp*^{(Na)} is what we call *fp*.

A maximum of 12*P* different *p*_{4}-codewords can be obtained from a polyhedron and its mirror image, where *P* is the number of peaks on the polychoron. Given that *ps*_{3} and *fp* can be read as *C*- and 3*N*_{na} -digit numbers, respectively, we define Lex(*p*_{4}) as the concatenation of the two numbers. We use the lexicographically smallest *p*_{4} as the representative one.

### Affected polychora

We first define the *degree of a peak* as the number of polyhedra contributing to that peak. We call a peak of degree more than three an *affected peak*. We say a polychoron without an affected peak to be *non-affected*. Reversely, an *affected polychoron* has one or more affected peaks. The *p*_{4}-code for non-affected polychora formulated above can be generalized to affected ones by using a one-to-one correspondence between an affected polychoron and its associated non-affected one as described below.

Any affected polychora can be transformed into a non-affected one by cutting its affected peaks. However, when different affected peaks are incident to the same 0-face, different non-affected polychora are obtained depending on the order of cutting. Therefore, we first assign peak IDs, and then cut the affected peaks in the ascending order of peak ID.

Suppose that we create a cross-section cell (cs-cell) by cutting an affected peak *XY*, connecting the 0-faces *X* and *Y*. We say its 0-face to be type-*X* (type-*Y*), if it is the cross section of a peak incident to *X* (*Y*). The ridges of the cs-cell are classified into three types: type-*X* ridges consisting of only type-*X* 0-faces, type-*XY* ridges consisting of both type-*X* and type-*Y* 0-faces, and type-*Y* ridges consisting of only type-*Y* 0-faces. In other words, by cutting a peak *XY*, it is mapped to a cs-cell in such a way that its endpoints are mapped to either type-*X* or type-*Y* ridges. Note that the type-*X* and -*Y* ridges do not adjoin each other because the type-*XY* ridges separate them, and that the number of the type-*XY* ridges is the same as the degree of the peak *XY*. In the example shown in Fig. 7, by cutting the affected peak *XY* of degree four, the 0-faces *X* and *Y* are mapped to the cross-section ridges *a′b′c′d′* and *e′f′g′h′*, respectively. Four cross-section ridges *a′d′h′e′, b′a′e′f′, c′b′f′g′*, and *d′c′g′h′* are type-*XY*.

Based on the above discussion, an affected polychoron can be encoded as follows:

Choose a face and an edge of an affected polychoron as an initial face and edge, and then assign peak IDs.

Cut the affected peaks in the ascending order of peak ID.

Encode the associated non-affected polychoron from the initial face and edge corresponding to the ones used in procedure (1).

To identify the cs-cell that is created when we cut an affected peak, we denote, for example, the

*p*_{3}-codeword for a cs-hexahedron as . Here, four double lines on 4 designate that the cs-hexahedron is mapped from the affected peak of degree four and that the four 4-gonal faces contribute to the type-*XY*ridges.

For example, a *p*_{4}-codeword for a polychoron shown in Fig. 7a is , where H = 4^{6} and .

Decoding is achieved easily. We first reproduce the associated non-affected polychoron, and then shrink the cs-cells to the corresponding affected peaks.

To define Lex(*p*_{4}), we define Lex(*ps*_{3}) for a non-simple polychoron as the concatenation of Lex(*ps*_{3}^{(1)}) and Lex(*ps*_{3}^{(2)}). Here, *ps*_{3}^{(1)} is the codeword obtained from *ps*_{3} as follows. We first replace every *p*_{3} with 0 except *p*_{3}s for the cs-cells corresponding to the affected peaks. We then deal with the *p*_{3}s for the affected peaks, and replace the digits without double lines with 0 and remove the double lines. The *ps*_{3}^{(2)}-codeword is the one obtained by removing double lines from *ps*_{3}. For example, Lex() is the concatenation of 0000000X and HHHHHHHH, namely, 0000000XHHHHHHHH. Here, X = 044440.

As in the case of polyhedra, the duality of polychora^{20} can be used to make a codeword more compact. For example, by using the duality, the representative *p*_{4}-codewords for 5-, 8-, 16-, 24-, 120-, and 600-cells^{12} are encoded as T^{4}, H^{8}, ^{★}H^{8}, O^{24}, D^{12}, and ^{★}D^{12}, respectively. Here, T, O, and D are the representative *p*_{3}-codewords for the tetrahedron 3^{4}, octahedron ^{★}H, and dodecahedron 5^{12}, respectively. Note that “^{★}” in “^{★}H^{8}” indicates the dual of H^{8}, and Lex (^{★}*p*_{4}) is defined as the concatenation of Lex (^{★}) and Lex(*p*_{4}).

### Describing a polyhedral tiling

Since a complex of polyhedra can be regarded as a partial polychoron, the *p*_{4}-code can be used to describe the arrangement of polyhedra in polyhedral tilings. The complex of polyhedra shown in Fig. 8, for example, is encoded as a partial *p*_{4}-codeword O_{t}HG_{3rd}^{4}(HG_{3rd})^{4}H. Here, by a partial *p*_{4}, we mean that decoding it results in a partial polychoron. O_{t} (=46^{4}(46)^{4}4) and H (=4^{6}) are the representative *p*_{3}s of the truncated octahedron and hexahedron, respectively. G_{3rd} (=6(48)^{3}(64)^{6}(84)^{3}6) is the third smallest *p*_{3} of the great rhombicuboctahedron.

## Discussion

In this work, we have created the theory of polyhedral tilings, which allows us to convert a local arrangement of polyhedra into a partial *p*_{4}-codeword that represents what polyhedra are tiled in what way. Traditionally, the index *c*_{3}*c*_{4}*c*_{5}∙∙∙ has been used to classify polyhedra in polyhedral tilings of liquids, glasses, grains and foams, where *c*_{i} is the number of i-gons on the polyhedron^{1,2,3,4,5,6,9,11}. However, the index sometimes fails to distinguish polyhedra with different structures, which prevents a close investigation of disordered structures. For example, the 35664453-polyhedron and 34566543-polyhedrdon have the same index, 2222000···. Although the Weinberg code may be a possible remedy and has been used recently^{11}, its codeword is lengthy and therefore redundant, still hampering our understanding of disordered structures. For example, the Weinberg codeword of the most frequently found polyhedron in the Poisson-Voronoi tessellation is “ABCACDEFAFGHIBIJKDKLELMGMNHNJNMLKJIHGFEDCB”. In contrast, using our *p*_{3} code, the same polyhedron is encoded as “356645445”. We also note that when the Voronoi polyhedron associated with an atom is encoded as 356645445, the atom is surrounded by neighbouring atoms forming a ★356645445-polyhedron. Our method thus allows us to describe polyhedral tilings succinctly, which is essential to understand disordered structures. In addition, although the short-range order can be studied by the previous methods, the long-range order cannot. Only our theory allows us to characterize what polyhedra are tiled in what way, and thereby paves the way to study from short- to long-range order of disordered structures in a systematic way. Moreover, our theory can be generalized to higher-dimensional polytopes to study disordered structures of any dimension.

## Additional Information

**How to cite this article**: Nishio, K. and Miyazaki, T. How to describe disordered structures. *Sci. Rep.* **6**, 23455; doi: 10.1038/srep23455 (2016).

## References

- 1.
Bernal, J. D. The Bakerian Lecture, 1962. The Structure of Liquids.

*Proc. R. Soc. Lond. A***280**, 299–322 (1964). - 2.
Finney, J. Random Packings and Structure of Simple Liquids. 1. Geometry of Random Close Packing.

*Proc. R. Soc. Lond. A***319**, 479–493 (1970). - 3.
Finney, J. Random Packings and Structure of Simple Liquids. 2. Molecular Geometry.

*Proc. R. Soc. Lond. A***319**, 495–507 (1970). - 4.
Yonezawa, F. Glass Transition and Relaxation of Disordered Structures.

*Solid State Phys.***45**, 179–254 (1991). - 5.
Sheng, H. W., Luo, W. K., Alamgir, F. M., Bai, J. M. & Ma, E. Atomic packing and short-to-medium-range order in metallic glasses.

*Nature***439**, 419–425 (2006). - 6.
Hirata, A.

*et al.*Geometric Frustration of Icosahedron in Metallic Glasses.*Science***341**, 376–379 (2013). - 7.
Nishio, K., Kōga, J., Yamaguchi, T. & Yonezawa, F. Confinement-Induced Stable Amorphous Solid of Lennard–Jones Argon.

*J. Phys. Soc. Jpn.***73**, 627–633 (2004). - 8.
Nishio, K., Miyazaki, T. & Nakamura, H. Universal Medium-Range Order of Amorphous Metal Oxides.

*Phys. Rev. Lett.***111**, 155502 (2013). - 9.
Kraynik, A. M., Reinelt, D. A. & van Swol, F. Structure of random monodisperse foam.

*Phys. Rev. E***67**, 031403 (2003). - 10.
Ramella, M., Boschin, W., Fadda, D. & Nonino, M. Finding galaxy clusters using Voronoi tessellations.

*Astron. Astrophys.***368**, 11 (2001). - 11.
Lazar, E. A., Mason, J. K., MacPherson, R. D. & Srolovitz, D. J. Complete Topology of Cells, Grains, and Bubbles in Three-Dimensional Microstructures.

*Phys. Rev. Lett.***109**, 095505 (2012). - 12.
Coxeter, H. S. M.

*Introduction to Geometry*, Ch. 10, 148–159; Ch. 22, 396–414 (Wiley, 1989). - 13.
Weinberg, L. A Simple and Efficient Algorithm for Determining Isomorphism of Planar Triply Connected Graphs.

*IEEE Trans. Circuit Theory***13**, 142–148 (1966). - 14.
Manolopoulos, D. E., May, J. C. & Down, S. E. Theoretical studies of the fullerenes: C34 to C70.

*Chem. Phys. Lett.***181**, 105–111 (1991). - 15.
Brinkmann, G. Problems and scope of spiral algorithms and spiral codes for polyhedral cages.

*Chem. Phys. Lett.***272**, 193–198 (1997). - 16.
Fowler, P. W. & Manolopoulos, D. E.

*An Atlas of Fullerenes*, Ch. 2, 15–42 (Dover Publications, 2007). - 17.
Friedrichs, O. D., Dress, A. W. M., Huson, D. H., Klinowski, J. & Mackay, A. L. Systematic enumeration of crystalline networks.

*Nature***400**, 644–647 (1999). - 18.
Lord, E. A., Mackay, A. L. & Ranganathan, S.

*New Geometries for New Materials*, Ch. 8.8, 145–149 (Cambridge University Press, 2006). - 19.
Cromwell, P. R.

*Polyhedra*, Ch. 5, 181–218 (Cambridge University Press, 1999). - 20.
Ziegler, G. M.

*Lectures on Polytopes*, Ch. 5, 127–148 (Springer, 2012). - 21.
Wilson, R. J.

*Introduction to Graph Theory*, Ch. 1, 8–31 (Pearson, 2012). - 22.
Wilson, R. & Stewart, I.

*Four Colors Suffice: How the Map Problem Was Solved*, Ch. 3 and 4, 28–54, (Princeton University Press, 2013). - 23.
Persistence of Vision Pty. Ltd., Williamstown, Victoria, Australia. http://www.povray.org/

## Author information

## Affiliations

### National Institute of Advanced Industrial Science and Technology (AIST), Central 2, Umezono 1-1-1, Tsukuba, Ibaraki 305-8568, Japan

- Kengo Nishio
- & Takehide Miyazaki

## Authors

### Search for Kengo Nishio in:

### Search for Takehide Miyazaki in:

### Contributions

K.N. conceived the original idea of code for polytopes. K.N. and T.M. polished up the idea.

### Competing interests

The authors declare no competing financial interests.

## Corresponding author

Correspondence to Kengo Nishio.

## Supplementary information

## PDF files

## Rights and permissions

This work is licensed under a Creative Commons Attribution 4.0 International License. The images or other third party material in this article are included in the article’s Creative Commons license, unless indicated otherwise in the credit line; if the material is not included under the Creative Commons license, users will need to obtain permission from the license holder to reproduce the material. To view a copy of this license, visit http://creativecommons.org/licenses/by/4.0/

## About this article

## Further reading

## Comments

By submitting a comment you agree to abide by our Terms and Community Guidelines. If you find something abusive or that does not comply with our terms or guidelines please flag it as inappropriate.