You are currently browsing the tag archive for the ‘computing’ tag.

While trying to understand the Luby transform (LT) code, I stumbled upon the well known coupon collector’s problem. It took a while for me to figure out the connection, but as it turned out, there is a stronger connection between these two.  In LT parlance, if we were to use only degree one packets (that is, packets sent and collected as it is) what is the expected number of packets to be collected (when collected randomly, one at a time) such that all the required packets are collected atleast once. For illustration let us say we have n information packets at the transmitter. The receiver collectes these one by one at random. How many packets on the average, we need to collect until we have collected all of the n different information packets. Remember we are collecting the packets randomly (On the other hand, if we were to collect things deterministically, we just need to collect n packets to get all these n, when done without replacement).

Assume that there are n distinct coupon types.  We have, a large pool of these coupons at disposal. Every time you go to the shop you collect a coupon picked uniformly at random from the pool.  The picked coupon has equal probability of  being any of the n types.  Naturally, some of the collected coupons (over multiple visits to the shop) may be of the same type. The question asked is this:  Suppose the coupon collector aims to have coupons of all types.  How many (number of visits) coupons he  has to collect till he possess all the n distinct types of coupons?

In expectation, the coupon collector should make  n \log(n) + O(1) visits to the shop in order to have atleast one copy of all n distinct types of coupons . This coupon collector problem can sound a little confusing to a fresh reader. For simplicity sake we can assume that, there are n differently coloured coupons at the shop. The question then is, on average (i.e., expectation) how many times one needs to visit (each visit fetch a coupon) the shop so that all coloured coupons are fetched atleast once.

There are n different type of coupons.  The coupon collector collects a coupon upon each visit. The collected coupon is among the n types, picked uniformly at random (from a set of possibly large pool of coupons) .  Since the coupon is drawn uniformly at random, there is a non zero probability that some of the collected coupons over multiple visits may be of the same type.  Suppose that at some stage, the coupon collector has r different type of coupons collected.  The probability that his next visit fetch a new coupon type (not of the r types he already have in the kitty) is p_r=\frac{n-r}{n}.  So, the expected number of coupons to be collected to fetch a new coupon type is \frac{n}{n-r}.  Let us denote this number by E\left[N_r\right].

The expected value E\left[N_i\right]=\frac{1}{p_i}=\frac{n}{n-i}. From this we can compute the expected value of N. In other words, E[N], the expected number of coupons to be collected (i.e, number of visits to the shop!) so that, the he would have all the different n types of coupons is:

E[N]=\displaystyle \sum_{i=1}^{n-1} {\frac{n}{n-i}}=n\sum_{i=1}^{n-1}{\frac{1}{i}}=nH(n)=n\log(n)+O(1)

So, what is the trouble? This number n\log(n) is prohibitively high a number to be acceptable (as decoding time of n\log (n) is significantly higher than the wishful linear time n!). So, simply using degree 1 is not a good idea. This is why Luby went ahead and identified some smarter distribution like Soliton (and its variants proposed later on, such as robust soliton and then the recent raptor codes by Amin).


May 2019
« Mar    

Enter your email address to follow this blog and receive notifications of new posts by email.

Join 86 other followers


%d bloggers like this: