Francisco Claude-Faust

Binary search without division, shifts or multiplications

2020-05-05T11:00:16+00:00

I subscribed to the daily coding problem a while ago by recommendation from a friend. I only have the free version, just for fun. You get a problem per day, with no solution (unless you pay), the difficulty varies.

Last week I got a problem that asks you to implement a search function that runs in $O(\log n)$ time over a sorted array without using division, shifts, or multiplications.

The problem is fun, and at least in my case, my first intuition was wrong. I will go through my solutions and compare them.

Dicemath – a small Go service for keeping kids busy

2020-04-19T15:00:00+00:00

I know this may not be the most fun activity for kids, but it turns out that my 5-year-old likes to do simple addition worksheets. Now that many of us are working from home with our kids, which is mostly trying to work from home while our kids prevent it, we have to take anything we can to keep the little ones busy and entertained.

I can’t complain. Working from home with two little kids is hard, but the truth is that we are amazingly lucky that everyone close to us so far is healthy, and on top of that, we can work; I’m amazingly grateful for that!

Back to the article, since my son likes to do worksheets where he can count the result of the additions, I built a small website that generates the worksheet. Every morning I print him one sheet, and he goes to either do the exercises or runs away from me because I’ll bug him with something he doesn’t want to do at the moment, win-win.

The live site is no longer available (link removed). I’ll spend the rest of the article explaining how I built and set the site up. It’s a small example you can go through in one day, and it’s always fun to pause things and do something different. You can find the whole project here (no, I did not write any tests; this was a one-day fun project; that’s it).

SICP Problem 2.6

2020-04-15T03:00:00+00:00

This is a short fun exercise I also went through while reading SICP. The problem gives a definition for zero and a function to compute the next integer (add 1):

(define zero (lambda (f) (lambda (x) x)))

(define (add-1 n)
  (lambda (f) (lambda (x) (f ((n f) x)))))

The problem asks you to write the function that adds two numbers without using add-1 iteratively.

SICP Problem 1.28

2020-03-27T14:00:34+00:00

In this post, I’ll go through some fun I had last week with problem 1.28 from SICP. The problem statement asks you to implement the Miller-Rabin primality test in Scheme. I had not read this book and picked it up because of how many times I’ve seen it recommended. So far, I have to say it has been a fun ride; I’m enjoying it a lot!

I started with that implementation, but then I sort of got into implementing my own ‘prime?’ function (a function that determines whether an integer is a prime number or not). I decided to limit it to implement a function that works for numbers up to 1 billion. This restriction is entirely arbitrary, but it’s big enough to have fun with it.

Important disclaimer: the code in this article is a fun little exploration. If you need to test primality in real life, I recommend looking at this paper before deciding on how to go with your implementation.

Consistent Hashing (Part 1)

2020-02-29T23:59:57+00:00

Consistent hashing is a well-known method for distributing stuff around multiple servers. We will implement a simple consistent hashing using Python and play a bit with it. This first part just focuses on having a way of computing hashes, we will build upon this in the later parts.

My Old WordPress in docker

2020-02-01T07:00:00+00:00

This blog was offline for about 7 years. Before this, it was a self-hosted WordPress installation for which I had (somewhat buried in my backups) an up-to-date dump of the MySQL database. Once I managed to find the backup that survived to live in 5 houses, moving between 3 countries, and my messiness, I didn’t have anywhere to load it; the server hosting the blog was not there anymore. I was planning on using a one-click install in DigitalOcean, since I didn’t want to spend time setting up Apache, PHP, and all required things to run WordPress. I was not sure if I could plainly load this old database into a more modern WordPress, so I decided to experiment a bit running things in docker first.

The first step was to load the database into a container; I had a file called fclaude_blog2.sql containing the old dump. I loaded the database (the default authentication plugin is because the default authentication of the latest version of MySQL is not supported, you can also get around by spinning an older version fo MySQL):

docker run --name wp-mysql -p 3306:3306  \
  -e MYSQL_ROOT_PASSWORD=nopass -d mysql \
  -default-authentication-plugin=mysql_native_password

The default authentication plugin setting is because the default authentication of the latest version of MySQL is not supported. You can also get around by spinning an older version fo MySQL. Once the database was running, I just pushed the dump into it:

exec -i wp-mysql mysql -uroot -pnopass 
# (typed 'create database fclaude_blog' and then closed the shell)

exec -i wp-mysql mysql -uroot -pnopass \
  fclaude_blog < Documents/fclaude_blog2.sql

Now I could see my data, but I wanted the XML export to load into my new WordPress, and to do so, I needed to run WordPress and connect it to this database.

docker run -ti --name wp -p 8080:80 -e WORDPRESS_DB_USER=root \
  -e WORDPRESS_DB_PASSWORD=nopass -e WORDPRESS_DB_HOST=wp-mysql \
  -e WORDPRESS_DB_NAME=fclaude_blog --link wp-mysql -d wordpress

Note that this is the settings of the MySQL we just set up, adding the –link option, so this container sees the container running the database.

The most amazing part, at least to me, is that as soon as I accessed http://localhost:8080/wp-admin/ WordPress told me the database was in an old format and offered to upgrade it. It worked perfectly, so now I was ready to log into my blog, and get the file I needed! Except that I did not remember the password anymore!

Following the WordPress documentation, I found that the password in the database was an md5. Per their recommendation, you could write the password in a text file, run the following command, and then delete the file (hopefully).

tr -d '\r\n' < pass.txt | md5sum | tr -d ' -'

I went into the MySQL container and updated the users’ table, setting the password field to the result from that command. And that was it! Then I could export my data and load it into this blog.

After this, I just did:

docker kill wp wp-mysql
docker rm wp wp-mysql

And now, my machine is also not full of stuff I had no intention of permanently installing locally in the first place.

Through all this experiment, the part I’m most surprised by is how WordPress handled the old database. I have no idea what changed, but still, now my database was up to date and working. Kudos to WordPress for this!

Increasing the memory limit in Go

2012-09-18T20:37:03+00:00

Yeah, it's been a while, but instead of talking about why I haven't written anything, I'll just jump into the good stuff.

I've been developing in Go lately. If you haven't tried it yet, I totally recommend it. Honestly, when you first look at the language, you tend to think that there is nothing new in there. That may be true. Many of the features are not unique, and you can find them in other languages, yet the combination is unique. After one week of using Go I didn't want to move back to C++ (what I usually use). There are a couple of things I miss from time to time, but the gain is so big that I don't mind.

The problem. I've had a couple of problems dealing with the kind of software I usually implement. Today I found one that did worry me a lot, I can't use more than 16GB of RAM! After that, my code will just crash with an "out of memory" error. In general this is not too bad, but for the particular algorithm I'm running, I need more than 16GB. Luckily, I found out that the limitation is temporal and that you can lift it up by changing just a couple of lines in Go's source code. So here it goes.

I will assume you installed Go in $HOME/bin/go (if not, don't worry, we are going to re-install it, right there).

The first step is to get the source for Go:

$ wget http://go.googlecode.com/files/go1.0.2.src.tar.gz

Once that finishes, decompress the package:

$ tar xvfz go1.0.2.src.tar.gz

Now, using your favourite editor, change the following files as explained here:

In file go/src/pkg/runtime/malloc.h
Change line 119, where it says "MHeapMap_Bits = 22," for "MHeapMap_Bits = 25,"
In file go/src/pkg/runtime/malloc.goc
Change line 309, where it says "arena_size = 16LL<<30;" for "arena_size = 128LL<<30;"

And that's it, now lets install this.

$ cd go/src
$ ./all.bash
$ cd ../..
$ mkdir -p $HOME/bin/go
$ mv go $HOME/bin/

Now we are ready. Remember to set the environment variable in your .bashrc:

export GOROOT=$HOME/bin/go
export PATH=$PATH:$GOROOT/bin

You are ready to enjoy 128GB. If you want 64GB, change the 25 for 24, and the 128 by 64.

This is supposed to be experimental, so please don't blame me if things crash. There has to be a reason for that limitation to be there. In my case, I was able to get away with this and run my code. In this particular case is the (expensive) construction of a compressed text index, so the thing runs, outputs, and that's it. Afterwards I process the output with other binaries. I'm just happy if the program manages to go through the construction, without much care on the resources I'm using at the time.

SXSI

2011-11-01T03:19:55+00:00

After a while I can happily say that our SXSI system is available for downloading. Kim created a package that can be easily installed and tested. In this post, I include a step by step tutorial on how to build the system and index a sample XML file.

First we need to install the dependencies in our system. In this case, I'll show how to do it in Ubuntu 11.10.

$ sudo apt-get install ocaml-ulex ocaml-findlib ocaml-nox libxml++2.6-dev camlp4

Then, download the package. To decompress and compile the package do:

$ tar xvf sxsi.tar.gz
$ cd sxsi/libcds
$ make
$ cd ../xpathcomp/src/XMLTree
$ make clean all
$ cd ../../
$ ./configure
$ ./build
$ cd xpathcomp

This generates a binary called "main.native". This binary allows you to index and query xml files. Lets first generate an xml file with the standard xmark tool

$ ./gen_xml -f 1 > sample.xml

Now, in order to index this file we run:

$ ./main.native -v -s sample.srx sample.xml ""
Parsing XML Document : 84729.9ms
Mem use before: VmRSS:	    5380 kB
Mem use after: VmRSS:	  117652 kB
Building TextCollection : 189371ms
Mem use before: VmRSS:	  117916 kB
Mem use after: VmRSS:	  237264 kB
Building parenthesis struct : 303.961ms
Mem use before: VmRSS:	  237264 kB
Mem use after: VmRSS:	  237528 kB
Tags blen is 8
Building Tag Structure : 4715.13ms
Mem use before: VmRSS:	  237528 kB
Mem use after: VmRSS:	  214988 kB
Number of distinct tags 92
Building tag relationship table: 1209.822893ms
Parsing document: 280366.960049ms
Writing file to disk: 115.392923ms
character 0-0 Stream.Error("illegal begin of query")

Yes, I gave an empty query, but I didn't want to search anything yet ;-). We have an indexed version of sample.xml with standard options saved as sample.srx. You can play with different indexing options, run main.native without parameters to see the full set of options supported at the moment. The result so far looks like this:

$ ls -lh sample.*
-rw-r--r-- 1 fclaude fclaude 188M 2011-10-31 23:10 sample.srx
-rw-rw-r-- 1 fclaude fclaude 112M 2011-10-31 23:02 sample.xml

Finally, as an example, we can count the number of results for the query "/site/regions/africa":

$ ./main.native -c -v sample.srx /site/regions/africa
Loading tag table: 4.344940ms
Loading parenthesis struct : 304.395ms
Mem use before: VmRSS:	    5380 kB
Mem use after: VmRSS:	    7492 kB
Loading tag names struct : 0.049ms
Mem use before: VmRSS:	    7492 kB
Mem use after: VmRSS:	    7492 kB
tags_blen is 8
11 MB for tag sequence
Loading tag struct : 11.366ms
Mem use before: VmRSS:	    7492 kB
Mem use after: VmRSS:	   27492 kB
Loading text bitvector struct : 11.738ms
Mem use before: VmRSS:	   27492 kB
Mem use after: VmRSS:	   29076 kB
Loading TextCollection : 144.782ms
Mem use before: VmRSS:	   29076 kB
Mem use after: VmRSS:	  194604 kB
Loading file: 478.782892ms
Parsing query: 0.061035ms
Parsed query:
/child::site/child::regions/child::africa
Compiling query: 0.048876ms
Automaton (0) :
States {q₀ q₁ q₂ q₃ q₄}
Initial states: {q₀}
Marking states: {q₀ q₁ q₂ q₃}
Topdown marking states: {q₀ q₁ q₂ q₃}
Bottom states: {q₀ q₁ q₂ q₃ q₄}
True states: {q₄}
Alternating transitions
_________________________________
(q₀, {'' })         → ↓₂q₀ ∧ ↓₁q₁
(q₀, Σ)             → ↓₂q₀
(q₁, {'site' })     → ↓₂q₁ ∧ ↓₁q₂
(q₁, Σ)             → ↓₂q₁
(q₂, {'regions' })  → ↓₂q₂ ∧ ↓₁q₃
(q₂, Σ)             → ↓₂q₂
(q₃, {'africa' })   ⇒ ↓₂q₃ ∧ ↓₁q₄
(q₃, Σ)             → ↓₂q₃
(q₄, Σ)             → ↓₂q₄ ∧ ↓₁q₄
_________________________________
Execution time: 1.343012ms
Number of results: 1
Maximum resident set size: VmHWM:	  200084 kB

And that's it. Now you can play further with SXSI :-)

Disk Crash, Recovering Files and Doing Backups

2011-05-16T05:11:17+00:00

About one and a half weeks ago I had a disk crash. I didn't lose anything, but was pretty close, mainly because I deleted by hand an important file :-(.

It is interesting to talk about my disk crash because I faced many problems to bring my computer back. Luckily my notebook has two hard drives, so I'm up and running with the secondary one now, but to do so I had to clone the recovery partition. Then I copied my backups to my home directory, and in the process I deleted an important file, which took me days to recover. And finally, I wrote a small script to back up things. This script is not a program (there is no error checking or anything like that), but it shows how to keep an encrypted backup.

Land of LISP and Lazy Evaluation

2011-05-01T10:00:24+00:00

One of my recent read was "Land of LISP" by Conrad Barski. It's an unconventional programming book, packed with comics. Most examples are tiny games you can code in a couple of pages. I personally liked the book a lot, it is fun to read and presents a language that, in my opinion, is also fun.

My experience with LISP is quite limited, so most of the things I found in the book were new to me (I knew how to define functions and basic stuff, but nothing about macros, only a couple of built-in functions, etc.). One of the things I liked the most was one of the examples for macros where the author presents a simple solution to get lazy evaluation. In the book, the author codes a game with some weird rules, and I don't think I would learn much by just copying that example, therefore, I will use the same idea here but with our old friend tic-tac-toe. I have to warn you that the implementation I'm going to post is not a good tic-tac-toe implementation, you can probably find more challenging opponents. The main goal of this exercise is to illustrate the lazy evaluation. Having said that, lets get started.

Finding the most significant bit

2011-04-13T23:59:49+00:00

In one of the problems I've been working on with Diego Seco and Patrick Nicholson, we needed the most-significant-bit (msb) function as a primitive for our solution. As Diego pointed out today, this function was one of the bottlenecks of our structure, consuming a considerable amount of time.

In this post I'll go through the solutions we tested in our data structure.

Seven Languages in Seven Weeks

2011-04-04T07:45:17+00:00

I read this book, by Bruce Tate, some weeks ago and totally recommend it. You can buy it from amazon or the pragmatic bookshelf.

What's in it?

From the title of the book is easy to get an idea. This book explores seven different programming languages, the idea is that you spend one week using each programming language and get an idea of what's out there to offer alternatives to the standards we are used to. By the standard I mean what I consider the standard, based on my experience most people program in Python, PHP, C++, C# or Java**.**

The languages covered are: Ruby, Io, Prolog, Scala, Erlang, Clojure, and Haskell.

The book has one chapter per language (plus intro and wrap-up chapters). Each language is presented in three parts, called days. Usually the first one shows the very basics, like input/output or math operations. The second day is usually used to present something that is different for this language, and the third day to present a harder example where the language shows to be useful and superior to others. For example, in Prolog, you can solve Sudoku puzzles by day 3 with little effort.

I liked several things about this book.

The third day shows you an example where the language actually helps you. This is in contrast to what my programming languages course was, where we went through 4 different languages. In that course we implemented pretty much the same things in each language. Maybe someone would disagree with my following statement, but in my opinion, implementing QuickSort in Prolog just makes you think you are wasting your time. You know how to implement it in C, and it works faster, so what's the point? In this book you don't do that kind of things. As I mentioned before, one of the examples for Prolog is solving a Sudoku puzzle. This shows you something great about the language. You can do this with almost no effort. If you try implementing it in another language, say Java, it is certainly going to take more effort.
The presentation is clear. It is easy to follow and you don't feel lost at some point looking at code you don't understand. For instance, in the basics, you usually go through basic math operations which are really similar to at least one language you know, yet the author takes the time to go through them. The explanations are of the right length to not be boring either, which is also a great plus. Another point regarding the basics, the author goes into things like typing with examples of that part, which also makes it much more interesting.
You are likely to find lots of things you didn't know. In my case, I haven't been exposed to that many programming languages, most of them imperative and object oriented. The only language I knew besides that was Scheme and some Common Lisp. I had a great time reading about these other languages that are somehow different and offer powerful constructs that make it easy to do things I know to be hard. For example, the future objects in Io, or the way you can build a service monitor in Erlang.
The author is not selling you the languages. Well, maybe some of them more than others. But the important point is that I didn't find the book to be too biased. In fact, for every language the author presents it and finishes listing advantages and disadvantages. This is a great thing, not only you get information about when to use a language, but also when not to.
You get to hear from the people that invented the languages (or important users of it). In every chapter you get to see an interview with someone that can be considered as a worthy representative of the language. I found this really interesting, and adds external opinions to the book, which I think, increases its value.

It is important to make clear that you will not learn the seven languages by reading this book. I would not recommend it to someone trying to learn how to program or trying to learn one of those seven languages.

If you know how to program, and enjoy it, you should consider buying it.

The SXSI System

2010-04-02T04:49:48+00:00

I promised a post about the ~~sexy~~ SXSI system in my last post. Its awesome name stands for Fast In-Memory XPath Search over Compressed Text and Tree Indexes, which says much more about what it does.

The main idea for representing the XML file is as follows: the shape of the tree is represented using succinct balanced parentheses, the labels are represented with structures that support rank/select and access queries, and the text with a self-index for the collection of texts inside the xml file.

Let's go over each part:

The tree: the tree is represented using balanced parentheses, by doing a DFS over the tree and writing a '(' every time you start visiting a subtree and a ')' when you leave the subtree. This representation allows for very fast navigation over the tree, for a good reference about it see the paper by Arroyuelo, Canovas, Navarro and Sadakane. In the same order we keep another sequence that corresponds to the ids of each node in the tree, we write down the ids in DFS order. This representation allows to move though the tree fast and access node ids quickly. Besides that, something that is really interesting with this combination is the ability to jump to a node with a given id, we just need to perform a select query over the sequence of tags (recall that select(c,i) over a sequence obtains the position where the i-th c occurs). This last operation allows for traversing the tree only looking at the nodes that have a given id.
The self-index, representing every text in the XML tree, is based on the FM-Index. Every node that contains textual data introduces a text into the collection. All the elements are concatenated introducing delimiters and every text in the collection gets an id (in our representation the texts are at the leaves of the tree so it's easy to map back a forward). The id is given by the position of the delimiter in the BWT, and using a range searching data structure we can map to original leaf-id. This index allows for fast pattern matching among the text data present in the XML file.

This an overview, you can get more details looking the original paper. The nice thing is that by using this structures we allow for a flexible navigation of the structure, and an automaton-based search procedure achieves great practical results over real XML files (more details look at the experimental results in the paper). This makes SXSI an interesting option as engine for representing and querying XML files. The idea of the automaton was formalized a couple of days ago, you can see the paper by Maneth and Nguyen.

What's next? Well, we are not done, there are some operations we would like SXSI to support that aren't implemented yet. Another issue is that the structure is static. Making it dynamic in practice is quite tricky, as it usually is with succinct representations.

At this moment we are working on a first release (cleaning code, adding documentation, etc), and we hope to have something soon :-).

MFCS Talk

2009-08-24T20:58:41+00:00

As I said in the previous post the talk is ready and online. I'll use this space to tell a little bit about the result we achieved with Gonzalo Navarro for the paper "Self-Indexed Text Compression using Straight-Line Programs".

The main problem we address is indexing straight-line programs, which are a special kind of free-context grammars that represent a language composed of one single text. This can be used as a compressed representation of a text, for example, LZ78 and Re-Pair map to an SLP without much effort. The bad new is that finding the minimum grammar that generates the text is NP-Complete, so approximations have to be used.

The formal definition is: A Straight-Line Program (SLP) $\mathcal{G}=(X=\{X_1,\ldots,X_n\},\Sigma)$ is a grammar that defines a single finite sequence $T[1,u]$, drawn from an alphabet $\Sigma =[1,\sigma]$ of terminals. It has $n$ rules, which must be of the following types:

$X_i \rightarrow \alpha$, where $\alpha \in \Sigma$. It represents string $\mathcal{F}(X_i)=\alpha$.
$X_i \rightarrow X_l X_r$, where $l,r < i$. It represents string $\mathcal{F}(X_i) = \mathcal{F}(X_l)\mathcal{F}(X_r)$.

We call $\mathcal{F}(X_i)$ the phrase generated by nonterminal $X_i$, and $T=\mathcal{F}(X_n)$.

Given a pattern P and a text represented as an SLP, we focus on the following problems:

Count the number of occurrences of P in the text generated by the SLP
Locate the positions where the pattern occurs.

In the past this problem was approached from an online-searching point of view, our goal was to provide an index that supports searching in sublinear time on the size of the SLP. For the indexing approach we work on representing the SLP as a labeled binary relation. We consider a binary relation $\mathcal{R} \subset A\times B$ where $A=[n_1]$ and $B=[n_2]$, and a labeling function $\mathcal{L}:A\times B \rightarrow L$, where $L=[\ell]\cup \{ \perp\}$ is the set of labels and $\perp$ represents no label/relation between the pairs. We want to answer the following queries:

Label of a given pair.
Elements related to an element of B.
Elements related to an element of A.
Elements related trough a given label.
Given to contiguous ranges in A and B respectively, find the pair that belong to the relation where $a\in A$ is in the range for A and $b\in B$ is in it's range too.

The first theorem we include shows that each of this queries can be answered paying close to $O(\log n_2)$ time per element retrieved (element in the answer). Using that result we show how to modify an SLP so that the rules are sorted by lexicographical order and then represent this variant of the SLP in $n\log n+o(n\log n)$ bits of space, and support queries as:

Access to rules.
Reverse access to rules (given two symbols, which rules generates them in a given order).
Rules using a given left/right symbol.
Rules using a contiguous range of symbols.

All the queries require $O(\log n)$ time per datum delivered, as a direct consequence of our labeled binary relation representation. Finally, including some extra structures we get our final result (I'm not going to go into the details on how to use the SLP representation, or where the different trade-offs come from):

Theorem:

Let $T[1,u]$ be a text over an effective alphabet $[\sigma]$ represented by an SLP of $n$ rules and height $h$. Then there exists a representation of $T$ using $n(\log u + 3\log n + O(\log\sigma + \log h) + o(\log n))$ bits, such that any substring $T[l,r]$ can be extracted in time $O((r-l+h)\log n)$, and the positions of $occ$ occurrences of a pattern $P[1,m]$ in $T$ can be found in time $O((m(m+h)+h\,occ)\log n)$. By removing the $O(\log h)$ term in the space, search time raises to $O((m^2+occ)h\log n)$. By further removing the $O(\log\sigma)$ term in the space, search time raises to $O((m(m+h)\log n+h\,occ)\log n)$. The existence problem is solved within the time corresponding to $occ=0$.

There are some open problems we were stuck at the end of the paper included in the article and we are now working on a journal version with some interesting extensions.

Text Partitioning

2009-06-27T04:34:34+00:00

Today I saw this article posted in arXiv:

On optimally partitioning a text to improve its compression
Written by Paolo Ferragina, Igor Nitto and Rossano Venturini

I found this article really interesting and nicely presented. The problem they focus on is:

Problem: Given a compressor $C$ and a text $T$ of length $n$, drawn from an alphabet $\Sigma$ of size $\sigma$. Find the optimal partition of $T=T_1T_2\ldots T_k$ such that $|C(T_1)C(T_2)\ldots C(T_k)|$ is minimized.

This means that we want to cut the text in $k$ pieces, with $k$ unknown, such that applying the compressor $C$ over each piece achieves the best compression possible over the text. This is ignoring possible permutations of the text, such as the Burrows-Wheeler Transform (BWT).

A simple solution is to transform this problem into a shortest path problem, every position in the text is a node in the graph, and every node $i$ is connected with nodes $i+1,i+2,\ldots, n$. The cost of going from node $i$ to node $j < i$ is $|C(T_{i,j})|$. It is easy to see that the best partition obtains a total size equal to the minimum path from $1$ to $n$. Here I include a figure of the graph (using IPE :-)).

Example shortest path for text partitioning

The main problem is that just building this graph takes $O(n^3)$ time. Assume that $C$ takes linear time to compress a sequence, then building the graph takes:

\sum_{i=1}^{n-1} \sum_{j=i+1}^n j-i =\sum_{i=1}^{n-1}\sum_{j=1}^{n-i} j = \sum_{i=1}^{n-1}\sum_{j=1}^{n-1} j

= \sum_{i=1}^{n-1} O(n^2) = O(n^3)

In the paper they present an algorithm to approximate the problem, they require $O(n\log_{\epsilon+1}n)$ time and achieve an $(1+\epsilon)-$approximation. The main idea behind the approach is to approximate the graph in such a way that, by storing less edges, they can still approximate the cost of the minimum path. They show how to run the algorithm without building the approximated version of the graph, to keep the space consumption low. They also show how to estimate the size of the compression for 0-order and k-order compressors during the process.