GraCT: A Grammar based Compressed representation of Trajectories
Nieves R. Brisaboa, Adrián Gómez-Brandón, Gonzalo Navarro, José R. Paramá
aa r X i v : . [ c s . D S ] D ec GraCT: A Grammar based Compressedrepresentation of Trajectories ⋆ Nieves R. Brisaboa , Adri´an G´omez-Brand´on , Gonzalo Navarro , and Jos´e R.Param´a Depto. de Computaci´on, Universidade da Coru˜na, Spain { brisaboa, adrian.gbrandon, jose.parama } @udc.es Dept. of Computer Science, University of Chile, Chile. [email protected]
Abstract.
We present a compressed data structure to store free tra-jectories of moving objects (ships over the sea, for example) allowingspatio-temporal queries. Our method, GraCT, uses a k -tree to store theabsolute positions of all objects at regular time intervals (snapshots),whereas the positions between snapshots are represented as logs of rela-tive movements compressed with Re-Pair. Our experimental evaluationshows important savings in space and time with respect to a fair baseline. After more than two decades of research on moving objects, this field stillpresents interesting problems that represent a topic of active research. The re-newed interest to represent and exploit data about moving objects is mainly dueto the new context in which large amounts of data (from, for example, cellularphones informing about the GPS coordinates of their position in real time) needto be stored and analyzed. Therefore, new big data sets and new applicationdomains demand more efficient technology to manage moving objects.Traditional spatio-temporal indexes can be classified into two families, space-based indexes and trajectory-based indexes. Each type of index is adapted toanswer different types of queries. Indexes in the first family usually are mod-ifications of the classical spatial R-tree, like for example the RT-tree [17], theHR-tree [11], the 3DR-tree [14], the MV3R-Tree [13], or the SEST-Index [5].Those indexes efficiently answer queries which return the ids or the number ofobjects into a given spatial region at a specific time instant (time-slice queries)or at a specific time interval (time-interval queries), but they cannot efficientlyreturn the position of an object at a time instant or which was its trajectory during a time interval.The second family of indexes were designed to improve the management oftrajectories, like SETI [4], the CSE-tree [15], and trajectory splitting strategies ⋆ This work was funded in part by European Unions Horizon 2020 Marie Sk lodowska-Curie grantagreement No 690941; Ministerio de Econom´ıa y Competitividad under grants [TIN2013-46238-C4-3-R], [CDTI IDI-20141259], [CDTI ITC-20151247], and [CDTI ITC-20151305]; Xunta de Gali-cia (co-founded with FEDER) under grant [GRC2013/053]; and Fondecyt Grant 1-140796, Chile. We informally define trajectory as a list of positions in consecutive time instants.
Grammarbased Compressed representation of Trajectories (GraCT) . GraCT is a trajectory-oriented technique, that is, it belongs to the second family. However, it structuresthe index into snapshots of the objects taken at regular time instants, and logsof their movements between snapshots. This allows GraCT to efficiently answer time-slice and time-interval queries as well, by processing the logs between twosnapshots. Besides, GraCT represents data and index together, and uses gram-mar compression on the logs. This not only reduce the size of the representation,but also the nonterminals are enriched to allow processing long parts of the logfiles without decompressing them, and faster than with a plain representation.Its space savings allow GraCT fitting much larger datasets in main memory,where they can be queried much faster than on disk. K -tree The k -tree is a compact data structure originally designed for representing Webgraphs in little space, allowing its manipulation directly in compressed form [3].The k -tree is used to represent the adjacency matrix of the graphs, and it canalso be used to represent any type of binary matrices.The k -tree is conceptually a non-balanced k -ary tree built from a binarymatrix by recursively subdividing the matrix into k submatrices of the samesize. It starts by subdividing the original matrix into k submatrices of size n /k , being n × n the size of the matrix. The submatrices are ordered from leftto right and from top to bottom. Each of those submatrices generates a childof the root node whose value is 1 if there is at least one 1 in the cells of thatsubmatrix, and 0 otherwise. The subdivision proceeds recursively for each childwith value 1 until it reaches a submatrix full of 0s, or it reaches the cells of theoriginal matrix (i.e., submatrices of size 1 × k -ary tree (right up) for k = 2.Instead of using a pointer-based representation, the k -tree is compactlystored using two bitmaps T and L (see Figure 1). T stores all the bits of the k -tree except those in the last level. The bits are placed following a levelwisetraversal: first the k binary values of the root node, then the values of the sec-ond level, and so on. L stores the last level of the tree. Thus, it represents thevalue of original cells of the binary matrix.It is possible to obtain any cell, row, column, or region of the matrix veryefficiently, by just running rank and select operations [7] over the bitmap T : ig. 1. Example of binary matrix(left) and resulting k -tree conceptual representation(right up), and the compact representation (right down), with k = 2. Fig. 2.
An example of Re-pair compression. rank b ( T, p ) is the number of occurrences of bit b ∈ { , } in T up to position p , and select b ( T, j ) is the position in T of the j th occurrence of the bit b . Forexample, given a value 1 at position p in T , its k children will start at position p children = rank ( T, p ) × k of T , except when the position of the childrenof a node returns a position p children > | T | ; in that case we access instead L [ p children − | T | ] to retrieve the actual value of the cells. Similarly, the parentof a position p in T : L is q − ( q mod k ), where q = select ( T, ⌊ p/k ⌋ ), and q mod k indicates which is the submatrix of p within its parent’s. Re-pair [9] is a grammar-based compression method. Given a sequence of integers I (called terminals ), it proceeds as follows: (1) it obtains the most frequent pairof integers ab in I , (2) it adds the rule s → ab to a dictionary R , where s is anew symbol not appearing in I (called a nonterminal ), (3) every occurrence of ab in I is replaced by s , and (4) it repeats steps 1-3 until every pair in I appearsonly once (see Figure 2). The resulting sequence after compressing I is called C .Every symbol in C represents a phrase (a sequence of 1 or more of the integersin I ). If the length of the represented phrase is 1, then the phrases consists of anoriginal (terminal) symbol, otherwise it is a new (nonterminal) symbol. Re-Paircan be implemented in linear time, and a phrase can be recursively expanded inoptimal time (that is, proportional to its length). Our approach
GraCT represents moving objects that follow free trajectories on the space. Weconsider the time as discrete, therefore each time instant actually corresponds toa short period of time. We assume that in each time instant, each object informsits position (e.g., international regulations require that ships inform their GPSposition at regular intervals). We use a raster model to represent the space,therefore the space is divided into cells of a fixed size, and objects are assumedto fit in one cell. The size of the cells and the period used to sample the timeare parameters that can be adapted to the specific domain.Every s time instants, GraCT uses a data structure based on k -trees to rep-resent the absolute positions of all objects. We call those time instants snapshots.The distance s between snapshots is another parameter of the system. Betweentwo consecutive snapshots the trajectory of each moving object is representedas a log, which is an array of movements, that is, relative positions with respectto the previous time instant. Snapshots
Each snapshot uses a k -tree where a cell set to 1 indicates thatone or more objects are placed in that cell, whereas a 0 means that no objectis in that cell. However, we still need to know which objects are in a cell set to1. Observe that each 1 in the binary matrix corresponds to a bit set to 1 in thebitmap L of the k -tree. We store the list of object identifiers corresponding toeach of those bits set to 1 in an array, where the objects identifiers are sortedfollowing the order of appearance in L . We call that array perm , since that arrayis a permutation [8]. In addition, we need a bitmap, called Q , aligned with perm ,that informs with a 0 that the object identifier aligned in perm is the last objectof a leaf, whereas a 1 signals that more objects exist. Observe in Figure 3, theobject identifiers corresponding to the first 1 in L (which is at position 3 of L )are stored starting at position 1 of perm . In order to know how many objectsare in the corresponding cell, we access Q starting at position 1 searching for thefirst 0, which is at position 2, therefore there are two objects in the inspectedcell. By accessing positions 1 and 2 of perm , we obtain the object identifiers 4and 2. Now, in position 3 of perm starts the object identifiers corresponding tothe second 1 in L , and so on.With these structures used to represent the absolute positions of all themoving objects at snapshots we can answer two types of queries: – Find the objects in a given cell : First, using the procedure shown in Section2.1 to navigate downwards the k -tree, we traverse the tree from the rootuntil reaching the position n in L corresponding to that cell. Next, we countthe number of 1s in the array of leaves L until the position n ; this gives usthe number of leaves with objects up to the n th leaf, x = rank ( L, n ). Thenwe calculate the position of the ( x − Q , which indicates the last bitof the previous leaf (with objects), and we add 1 to get the first position ofour leaf, p = select ( Q, x −
1) + 1. Then p is the position in perm of the firstobject identifier corresponding to the searched position. From p , we read all ig. 3. The position of objects in the space (left), and the representing snapshot (right). the object identifiers aligned with 1s in Q , until we reach a 0, which signalsthe last object identifier of that leaf. – Find the position in the space of a given object . First, we need to obtainthe position k in perm of the searched object. In order to avoid a sequentialsearch over perm to obtain that position, we add additional structures tocompute cells of the inverse permutation of perm [10]. Then, we have tofind the leaf in L corresponding to the k th position of perm . For this sake,we calculate the number of leaves before the object in position k of perm ,that is, we need to count the number of 0s until the position before k , y = rank ( Q, k − L the position of the ( y + 1) th
1, thatis, select ( L, y + 1). With that position of L , we can traverse the k -treeupwards in order to obtain the position in the space of that cell, and thusthe position of the object. Log of relative movements
The changes that occur between snapshots aretracked using a log file per object. The use of snapshots and logs is not new [16],but in previous works log values are stored according the appearance of “events”(such as objects that appear in or disappear from an area).The log stores relative movements with respect to the last known positionof an object, that is, to its position in the preceding time instant. Objects canchange their positions along the two Cartesian axes, so every movement in thelog can be described with two integers. Instead, in order to save space, we encodethe two values with a unique positive integer. For this sake, we enumerate thecells around the actual position of an object, following a spiral where the originis the initial object position, as it is shown in Figure 4 (left). Let us suppose thatan object moves with respect to the previous known position one cell to the Eastin the x-axis, and one cell to the North in the y-axis. Instead of encoding themovement as the pair (1,1), we encode it as an 8. In Figure 4 (right) we show thetrajectory of an object starting at cell (0,2). Each number indicates a movementbetween two consecutive time instants. Since most relative movements involveshort distances, this technique produces a sequence of usually small numbers.Sometimes real objects stop emitting signals during periods of time. Thisforces us to add two new possible movements inside a log: relative reappearance ig. 4.
Encoding object’s movements. and absolute reappearance . We reserve two codewords to signal these events. Weuse a relative reappearance when an object disappears and reappears betweenthe same snapshots, and an absolute reappearance otherwise. Relative reappear-ances are followed by the time elapsed from the disappearance and a relativemovement from that time instant, whereas absolute reappearances are followedby the number of time instants that elapsed since the disappearance and theabsolute values of the ( x, y ) coordinates of the new position of the object.
The log not only saves much space compared to using k -trees for every instant,but it also offers important opportunities for further compression. A first choiceis statistical compression, since as said, most movements are short-distanced andthus our spiral encoding uses mostly small numbers. We exploit this fact using( s, c )-Dense Codes (SCDC) [2], a very fast-to-decode statistical compressor thathas a low redundancy over the zero-order empirical entropy of the sequence. Wewill use this approach as fair baseline.The second approach, which gives the title to this paper, uses grammar com-pression on the set of all the log files. Our aim is to exploit the fact that there aretypical trajectories followed by many objects, which translate into long sequencesof identical movements that grammar compression can convert into single non-terminals. This includes, in particular, long straight trajectories in any direction. ScdcCT: Using SCDC for compressing the logs
The size of the cells andthe time elapsed between consecutive time instants must be carefully chosen torepresent properly the typical speed of moving objects, so that short movementsto contiguous cells are more frequent than movements to distant cells. Insteadof sorting the spiral codes by frequency, we will simply assume that smallernumbers are more frequent than larger ones. Since the ( s, c )-codes depend onlyon the relative frequency of the symbols, we do not need to store any statisticalmodel. Still, we will use the frequencies to optimize s and c in order to minimizethe space usage. raCT: Using Re-Pair for compressing the logs Moving objects spendmost of the time either stopped or moving following a specific course and speed.In both cases, the logs will present longs sections with numbers representing thesame or contiguous values of the spiral. For example, the moving object in Figure4 follows a NE trajectory moving one or two cells per time instant. Therefore itslog represents the series of relative movements 8,9,8,9,8,7,9,8,7,9; see the array I of Figure 2. Those series of similar movements are very efficiently compressedusing a grammar compressor such as Re-Pair. To avoid having to decompressthe log before processing it, we enrich the rules of the grammar R with furtherdata apart from the two symbols to be replaced. Specifically, each rule in R willhave the following information: s → a, b, t, x, y, M BR , where s , a and b are thecomponents of a normal rule of Re-Pair, t is the number of instants coveredby the rule, ( x, y ) are the relative coordinates of the final position of the objectafter the application of the rule, and M BR is the minimum bounding rectangleenclosing the movements of the rule.For example, the rules of Figure 2 are enriched as follows. The first rule of R is A → , , , (3 , , (0 , , , ,
2) indicates the positionof the object after the application of the rule if we start at (0 , B → , , , (4 , , (0 , , , C → , , , (1 , , (0 , , , D → A, A, , (6 , , (0 , , , C do not need to be decompressed in most cases. Assume we want to know theposition of the object at the 5 th time instant, which is when the object in Figure4 (right) is at position (7,7). The preceding snapshot informs that the absoluteposition of the object at the beginning of the log is (0,2). Next, we inspect thelog (the C array of Figure 2) from the beginning. The first value is a D . Theenriched rule indicates that such symbol represents 4 time instants, and after it,the object is displaced 6 columns to the East and 4 rows to the North, that is,starting at (0,2), after the application of this rule, the object will be at (6,6).Since our target time instant is later than the final time instant of this rule,we do not have to decompress it, and this is the usual case. The next symbolis C , which lasts 2 time instants. This would take us to time instant 6, butthis surpasses our target time instant(5). Therefore, in this case, that is, onlyin the last step of the search, we have to decompress the rule, and process itscomponents: C → M BR component aids during the computation of time-slice and time-interval queries, as we will see soon.The additional elements enriching the rules are compressed with an encoderdesigned for small integers (Directly Addressable Codes, DAC) that supportfficient access to any individual value in the sequence [1]. To obtain better com-pression, the times of all the rules are compressed with one DAC, separately fromthe 3 pairs of coordinates of all the rules, which are compressed with another.
Obtain the position of an object in a given time instant
This query issolved by accessing the snapshot preceding the queried time instant t q , wherewe retrieve the position of the object at the snapshot time instant. We thenapply the movements of the log over this position until we reach t q . In the caseof SCDC compression, we follow the log decoding each codeword and applyingthe relative movement to the previous position. In the case of Re-Pair, we followthe process described in the previous section. Obtain the trajectory of an object between two time instants
First,we obtain the position of the object in the start time instant t s , using the samealgorithm of the previous query; then we apply the movements of the log untilreaching the end time instant t e . In this case, when using GraCT, we have todecompress C to recover I , since only with I we are capable of describing thetrajectory in detail, and thus we cannot take advantage of the enriched nonter-minal data. Therefore this query is more time-consuming than the previous onefor GraCT, and scdcCT takes over. Time slice query
Given a time instant t q and a window rectangle r of thespace, this query returns the objects that lie within r at time t q , and theirpositions. We can distinguish two cases. First, if t q corresponds to a snapshot,we only need to traverse the k -tree until the leaves, inspecting those nodes thatintersect r . When we reach the leaves, we know their position and can retrievefrom the permutation the objects that are in this area.The second case occurs when t q is between two snapshots s i and s i +1 . Inthis case, we inspect in s i a region r ′ , which is an enlargement of the queryregion r . Region r ′ is defined using using the fastest object of the dataset as anupper bound. Thus, r ′ is the rectangle containing all the points from where wecan reach the region r at t q if moving at maximum speed along some direction.Then, from s i , we only track the objects that are within r ′ in the snapshot,therefore limiting the objects to follow and not wasting time with objects thatdo not have chances to be in the answer. We follow the movements of thoseobjects from s i using the log, until reaching t q . We further prune the tracking aswe process the log: a candidate object may follow a direction that takes it awayfrom region r , so we recheck the condition after every movement and discard anobject as soon as it loses the chance of reaching r at time t q .The tracking of objects is performed with the same algorithm explained forobtaining the position of an object in a given time instant, but in the case ofGraCT, when a non terminal in the log corresponds to a rule that brings theobject we are following from an instant before to an instant after t q , instead ofdecompressing the nonterminal, we intersect the MBR of the rule with r , and (cid:2) (cid:3) (cid:1)(cid:2) (cid:4)(cid:5) (cid:6)(cid:7)(cid:8)(cid:9) (cid:10)(cid:11) (cid:3) (cid:1)(cid:2)(cid:2) (cid:4)(cid:5) (cid:6)(cid:7)(cid:8)(cid:9) (cid:10)(cid:11) (cid:1) (cid:4)(cid:5) (cid:6)(cid:7)(cid:8)(cid:9) (cid:10)(cid:11) (cid:3) (cid:12) (cid:13)(cid:14)(cid:4) (cid:12) (cid:13) Fig. 5.
Example of enlarged region r ′ and query region r in a time-slice query. disregard the object if the intersection is empty. Otherwise we decompress thenonterminal into two and try again until reaching t q or discarding the object.Figure 5 shows an example where we want to find the objects that are locatedin r at t q . Assume that the fastest object can move only to an adjacent cell inthe period between two consecutive time instants. Let s i be the last snapshotpreceding t q and let there be 2 time instants between s i and t q . The left partof the figure shows the state of the objects at the time instant corresponding to s i , in the middle to s i + 1 = t q −
1, and in the right to t q , where we show theregion r . In r ′ (shown on the left grid) we have four elements (1,4,5,8), which arecandidates to be in r at t q , thus we follow their log movements. In the middlegrid, we show the region r ′′ where the objects still have chances to be within r at t q . Observe that, from the candidate objects in s i , object 4 has no furtherchances to reach r , and thus it is not followed anymore. However, object 1 stillhave chances, and therefore we keep tracking it.This query is affected by the time elapsed between s i and t q . The fartheraway s i and t q are, the larger r ′ will be, and thus, we will have more candidateobjects that have to be followed through the log movements. In addition, witha large period between s i and t q , we have to traverse a longer portion of thelog. To alleviate this problem, if t q is closer to s i +1 than to s i , we can start thesearch at s i +1 and follow backwards the movements of the log. For this backwardtraversal, we need to add before each snapshot the last known position and itscorresponding time instant of the objects that are disappeared at the time instantof the snapshot. This applies to both approaches scdcCT and GraCT. Therefore,the maximum distance will be half of the distance between two snapshots. Time interval query
In the time-slice query we have to know which objectsare in r at the query time instant and their positions, but in the time-intervalquery, the target is to know which objects were within r at any time instant ofthe time interval [ t s , t e ], specified in the query. In this case, we use the expandedregion r ′ again, which is built as in the time-slice query, but using the time t e . raCT scdcCTPeriod 120 240 360 720 120 240 360 720Size (MB) 196.79 193.31 192.24 179.60 312.27 263.46 273.20 282.95Ratio 39.27% 38.58% 38.36% 35.84% 62.32% 56.47% 54.52% 52.58%Snapshot (MB) 7.55 3.77 2.51 1.25 7.55 3.77 2.51 1.25(3.83%) (1.95%) (1.31%) (0.70%) (2.42%) (1.33%) (0.92%) (0.48%)Log (MB) 189.25 189.54 189.73 178.34 304.73 279.18 270.69 262.20(96.17%) (98.05%) (98.69%) (99.30%) (97.58%) (98.67%) (99.08%) (99.52%) Table 1.
Compression ratio.
Using SCDC, the objects within r at t s are reported as part of the solution,the other objects with chances at t s are followed until they reach the region r ,in which case they are added to the answer; or when they move such that theylose the chance to reach r at t e , in which case they are not followed anymore.In GraCT, we process the log without decompressing nonterminal symbolsuntil the final time of a symbol in the log is equal or larger than t s . After thismoment, for each symbol we read in the log, until the object is selected or thenext symbol in the log to read starts after t e , we follow the next procedure:For each log symbol we check if the final point is inside r . If it is, the objectis selected. If not, and the MBR does not intersect r , we go on to the nextlog symbol. If the final point is not in r but the MBR intersects r , we mustapply the same procedure recursively to the pair of symbols represented by thenonterminal, until the object is selected or we process the whole nonterminal. GraCT and scdcCT were coded in C++ and the experiments were run on a1.70GHzx4 Intel Core i5 computer with 8GBytes of RAM and an operatingsystem Linux of 64bits.
Datasets description and compression data
We use a real dataset obtainedfrom the site http://marinecadastre.gov/ais/ . The dataset provides the lo-cation signals of 3,654 ships during a month. Every position emitted by a shipis discretized into a matrix where the cell size is 50 ×
50 meters. With this datanormalization, we obtain a matrix with 100,138,325 cells, 36,775 in the x -axisand 2,723 in the y -axis. Observe that our structure deals with object positionsat regular intervals, but in the dataset ship signals are emitted with distinctfrequencies, or they can send erroneous information. Therefore, we preprocessedthe signals to obtain regular time instants every minute, thus discretizing thetime into 44,642 minutes in one month. With these settings, the original datasetoccupies 501 MBs.We built GraCT and scdcCT data structures over that dataset using differentsnapshot distances, namely every 120, 240, 360, and 720 time instants. Theconstruction time of the complete structure takes around 1 minute. Table 1shows the results of compression ratio , where we can see that GraCT obtains The size of the compressed data structure as a percentage of the original dataset. raCT scdcCTPeriod 120 240 360 720 120 240 360 720Ratio 39.27% 38.58% 38.36% 35.84% 62.32% 56.47% 54.52% 52.58%Object t q Slice S 1.5386
Table 2.
Time of different queries (ms). much better compression ratios than scdcCT. The rows snapshot and log showthe size of the snapshot and the log as a percentage of the compressed datastructure. We can see that the log is the most space demanding structure. Asreference we compress the plain data with p7zip and we obtain a compressionratio of 10,97%, which is better than GraCT, however with this compressed datais impossible to answer any type of query.
Query types and answer times
Table 2 shows the average answer times of50 random queries of different types: object t q shows searches for the position ofan object in a given time instant, trajectory searches for the trajectory followedby an object between two time instants, slice S are time-slice queries that checkfor small regions (367 ×
272 cells) and slice L for large regions (3677 × interval S are time-interval queries with a small region and a small time interval( of the snapshot period) and interval L with large regions and a large timeinterval ( of the snapshot period).GraCT is the overall winner in all queries, except in the trajectory query.This is expected, since to recover the trajectory, GraCT has to decode all thesymbols in C , given that the enriched information in rules does not have thedetails of the movements inside each rule. In the rest of the queries the enrichedinformation avoids in many cases to decode the rules in C , and thus, since thelogs in GraCT have far fewer values than in scdcCT, the searches are faster.The exception is when the size of the log between two snapshots is small, as theeffect is not noticeable. Notice that in this case the nonterminal symbols in thegrammar cannot represent arrays of more than 120 terminals. We have presented a grammar based data structure for representing movingobjects. It uses snapshots where the objects are represented in the space usinga k -tree and movement logs that are grammar-compressed. The results of thisfirst experimental evaluation are very promising, as compression yields significantreductions in both space and time performance with respect to the baseline.One reason why our space results are not even better is that the enricheddata pose a significant space overhead per nonterminal. We plan to improve ourepresentation by encoding these data in smarter ways. We also plan to compareGraCT with state of the art indexes aimed at both time-slice and time-intervalqueries, and trajectories. References
1. Brisaboa, N., Ladra, S., Navarro, G.: DACs: Bringing direct access to variable-length codes. Information Processing and Management 49(1), 392–404 (2013)2. Brisaboa, N.R., Fari˜na, A., Navarro, G., Param, J.R.: Lightweight natural languagetext compression. Information Retrieval 10(1), 1–33 (2007)3. Brisaboa, N.R., Ladra, S., Navarro, G.: Compact representation of web graphs withextended functionality. Information Systems 39(1), 152–174 (2014)4. Chakka, V.P., Everspaugh, A., Patel, J.M.: Indexing large trajectory data setswith SETI. In: Proceedings of the conference on innovative data systems research,CIDR 03 (2003),
5. Guti´errez, G.A., Navarro, G., Rodr´ıguez, M.A., Gonz´alez, A.F., Orellana, J.: Aspatio-temporal access method based on snapshots and events. In: GIS. pp. 115–124. ACM (2005)6. Hadjieleftheriou, M., Kollios, G., Tsotras, V.J., Gunopulos, D.: Efficient indexingof spatiotemporal objects. In: Proceedings of Advances in Database TechnologyEDBT 2002. pp. 251–268 (2002)7. Jacobson, G.: Space-efficient static trees and graphs. In: IEEE Symposium onFoundations of Computer Science (FOCS). pp. 549–554 (1989)8. Knuth: Efficient representation of perm groups. Combinatorica 11, 33–43 (1991)9. Larsson, N.J., Moffat, A.: Off-line dictionary-based compression. Proceedings ofthe IEEE 88(11), 1722–1732 (2000)10. Munro, J.I., Raman, R., Raman, V., Rao, S.: Succinct representations of permu-tations and functions. Theoretical Computer Science 438, 74–88 (2012)11. Nascimento, M.A., Silva, J.R.O.: Towards historical R-trees. In: George, K.M.,Lamont, G.B. (eds.) Proceedings of the 1998 ACM symposium on Applied Com-puting, SAC’98. pp. 235–240. ACM (1998), http://doi.acm.org/10.1145/330560http://doi.acm.org/10.1145/330560