Google runs spiders to collect information from web pages and these are indexed in a humongous database of phrases. When one of the phrases is googled, the results need to be rank ordered based on some metric, so as to be meaningful, which is where PageRank comes in. PageRank judges the importance of each page containing the phrase is judged as follows. (Note : this is a very simplistic explanation of the algorithm, which is definitely more complex and efficient)

: page j
: importance of page j (needs to be determined)
: number of links going out of page j

If links to , then confers of importance to .

Let be the set of all pages linking to .

This presents a chicken-and-egg problem, as the importance of each page is calculated from the importance other pages whose importance is in turn … so on.

Let us define H, the hyperlink matrix as :

H has all non-negative entries

Columns of H sum to 1 (unless the page has no outgoing links).

Set I vector of page ranks, . Then,

So, I is the eigenvector associated with H associated with eigen value 1.

Goal: Given H, find I.

H is a huge matrix (around 25 billion x 25 billion !), but several entries are 0. Still, each page has an average of 10 links, so it is a very hard problem.

Solution: Power Method

1. Pick an initial vector
2. Iterate,

In general, such an iterative systems converges, . Of course there are interesting questions which arise :

• Does it always converge ?
• Does the limit of the sequence depend of the initial vector?
• Does the limit of the sequence provide desired information ?

This exercise kind of gives some appreciation for what Google has to do constantly in order to provide relevant search results.

STD(n;q;k) is a matrix construction algorithm that accepts parameters : n,q and k to produce a (qk x n) 0-1 matrix with certain special properties. Each of the n columns has k 1′s in it, which are distributed, one in every q x n block. Each row has usually 1′s in it. Such matrices are very useful as pooling design schemes and error-correcting codes, among other things. The STD algorithm is due to N. Thierry-Mieg.

Expander Graphs are sparse but highly connected graphs. From here, we learn that a bipartite graph H = (X,Y,E) is said to be an ()-expander if |X|=n, |Y|=m, the degree of each node in X is d, and for every , the set of vertices that are adjacent to A satisfies . A higher value of implies a better expansion property.

The connection between STD’s and EG’s stems from the fact that STD(n;q;k) creates n distinct (actually disjunct) columns of length qk with column weight k and this is similar to the adjacency matrix of an unbalanced expander with left degree k and |X|=n and |Y|=qk.

To construct such a matrix, via STD, we do as follows :

Given the parameters n, q and k, the binary matrix STD(n;q;k) can be constructed as follows. The STD has a layered construction consisting of k layers of q x n binary matrices. For all , let be a boolean matrix representing layer , with columns . Let the circular shift operator, , be defined as, and . Note that is a cyclic function and when applied times maps onto itself, , . To design a layer , for all construct , where,

if :

if : where

The layers are put together to form by, .

Note : q is a prime number. To get the required m rows with column weight k, try to find the smallest prime, and .

In fact, any constant column-weight d-disjunct matrix has such a property. This property of d-disjunctness seems to be related to linear time decoding capabilities of codes. Not surprisingly, the STD is similar in nature to low density parity check (LDPC) codes.

The point of all this being that, STD has a very fast and clean construction method which could come in handy while creating expander graph-type structures (and codes with error-correcting properties). This is especially useful for the compressed sensing methods that use sparse matrices and the MATLAB codes that go with it.

% A STD-based method to create the sparse measurement matrix (used for compressed sensing)

% Here k is the number of ones per column
% qk is the number of rows
% So if m rows are needed, choose q : prime >= m/k and k<=q+1
% n is the number of columns

function M=std(n,q,k)

if rem(log(n),log(q)) == 0
Gamma=log(n)/log(q)-1;
else
Gamma=floor(log(n)/log(q));
end

flag=0;
% Check if STD Correction is needed
if k == q+1 && floor((n-1)/q^Gamma) < q-1
flag=1;
end

format short
M=zeros(k*q,n);
s=zeros(k,n);

C00=zeros(q,1);
C00(1)=1;

for j=1:k
for i=1:n
if j-1 < q
for c=0:Gamma
s(j,i)=s(j,i)+ ((j-1)^c)*floor((i-1)/q^c);
end
elseif j-1==q
s(j,i)=floor((i-1)/q^Gamma);
end

M((j-1)*q+1:j*q,i)=circshift(C00,s(j,i));
end
end

if flag==1
M((k-1)*q+(floor(n/q^Gamma)+1)+1:k*q,:)=[];
end

%End of Function

Some scientist-types have a week to throw a party. They have 7 bottles of wine in their cellar. However, the vintage bottles have lost their labels. Of these, 1 bottle was rat poison, but which one ? To test this out, they volunteer their pet rats, but have only 3 such rats. Also it takes a rat about a week to die of the poison. They need to figure out a way to test all 7 bottles using just 3 rats, such that, at the end of the week they know exactly which bottle was rat poison.

Being good scientists they do the following :

1. Feed a sip of bottle #1 (B1) to rat #1 (R1).
2. Feed a sip of bottle #2 (B2) to rat #2 (R2).
3. Feed a sip of bottle #3 (B3) to rat #3 (R3).
4. Feed a sip of bottle #4 (B4) to rats #1 (R1) and #2 (R2).

Thus, the death of both rats R1 and R2 would point only to bottle B4, not to B1 or B2.

5. Feed a sip of bottle #5 (B5) to rats #1 (R1) and #3 (R3).
6. Feed a sip of bottle #6 (B6) to rats #2 (R2) and #3 (R3).
7. We can do one of two things with bottle #7,

a. Let there be love strategy : Don’t feed any rat from this bottle and if all rats survive, this bottle was the poison. This strategy is handy if you, somewhat, love your pet rats. Clearly, you don’t love them completely as you are choosing wine-for-a-party over their lives !

b. Kill ‘em all strategy : Feed a sip of bottle #7 (B7) to all 3 rats (R1, R2 & R3).

Note: We assume that even in small sips the poison is always potent.

Now, suppose B5 was the poison, at the end of the week R1 and R3 would be in rat heaven. An illustration of this whole experiment looks like this :

Solution : If there are n items out of which exactly one item is special then the optimal non-adaptive (all tests specified at the start) strategy is to test them in mixes which are defined by the binary representation of the number assigned to each item in, . The number of digits needed for this representation is arrived at as, . For example, for 7 items are to be tested we need, at least, tests. When these are put together we get a binary matrix of size where the rows are the tests and the columns are the items to be tested. A 1 in a row implies that the item corresponding to that column is to be mixed in that test.

So, what was the point of all this ? We have arrived at a testing paradigm called group testing or pooling designs. It is a powerful idea that crops up in all sorts of places. It also lets us in on a fundamental limit of information collection. If we had, in general, at most d special items out of n (with all items equally likely to be special) and had to devise a pooled testing scheme, as described earlier, then we will need, at least, t tests, given by :

This is known as the information theoretic lower bound for the group testing problem. The derivation is as follows :

When there are at most d special items out of n, then the number of unique representations required of the outcome would be . This sums up all the possible ways in which we could have the special items present in n, anywhere from special items. Each case, would need a unique binary representation where the outcomes can be either 0 or 1 (failure or success). Therefore, the binary representation would require t digits :

But, we can approximate,

Using Stirling’s Approximation, .

Therefore, .

Now,

For large n, the term dominates. So,

+ (some constant)

Therefore,

We are therefore left with a strict lower limit on how much compression can be achieved by using pooling designs instead of standard testing (which would require n tests always). The compression essentially comes from the fact that each negative result of a pooled test eliminated a whole chunk of items.

However, a few things to note here :
1. The tests are assumed to be free of error.
2. d has to be a small fraction of n to get useful compression. As d gets closer to n/2, the pooling designs become unnecessary.
3. The algorithms to create the actual testing designs are a whole different matter.
4. The problem is NP-hard (PSPACE actually) , but there are
approximate algorithms.
5. The best ones operate like, in terms of tests needed.
6. Even for d=2, the algorithm operating at the lower limit is an open problem.

References :
[1] Combinatorial Group Testing – book by Du and Hwang.
[2] Hirschberg et. al. – lower bound proof idea.

where, is a vector norm and is the supremum, a sort of maximum value this value. In some sense, this measures the stretching that the matrix imparts onto the vector .

Interestingly, it can be shown that the norm is nothing but the maximum column (absolute) sum of the matrix and the norm is the maximum sum of absolute values of elements of a row in . More importantly, the useful norm is actually the largest singular value of .

We can also show how these norms are related to each other. For example,

To show this, first consider the vector norm relationship for .

Therefore,

Replace each with the maximum (absolute) value among them. Thus,

So, .

Now, we know, .

Using the inequalities from the vector norm, we have, and .

So, substituting them into the matrix norm definition, we get,

.

This is how we get, .

Similarly, (since the vector ) and , implies,

Finally, we get,