## Student Presentation #3

*(Guest post by Nathan Russell)*

I presented the first half of the paper On-Line Algorithms for Path Selection in a Nonblocking Network, by Arora, Leighton and Maggs.

Broadly speaking, nonblocking networks are networks of switches (represented by vertices) such that it is possible for any set of inputs to be pairwise connected to any set of outputs without conflict. The authors, in my part of the paper, set up background to present a network in which inputs can be connected to outputs by switches of bounded degree, using only bit steps. All of these bounds are known to be optimal. Additionally, the network can do this for multiple connections simultaneously.

I presented the butterfly and Benes networks, as well as the multi-butterfly and multi-Benes networks constructed by combining them, and gave intuition and prepatory proofs to set up for the authors’ eventual proof of how the networks are nonblocking when a series of splitters is combined with a series of mergers, each built out of multi-Benes networks.

## Property Testing Lecture 4

In the last lecture, we finished the proof of the soundness for the natural tester for testing graph bipartiteness. The main idea in the proof was to divide up the set of random vertices into two subsets and . The analysis proceeded by showing that with high probability over the choices of and , forms a “witness” to the fact that no bipartition of can be extended to a biparitiion of the input graph (which in turns implies that the input graph is not bipartite). The gain in this approach over the naive analysis is that has constant size and hence, one can take union bound over all possible partitions of .

In the second part of the lecture, we studied Locally Decodable Codes (LDCs). In particular a -locally decodable code has a local decoder with the following property. For any input (such that for a unique ) and , the decoder outputs the value with constant probability. We had already seen that the Hamming code is a -LDC for any . Hamming code has the optimal block length for any 2-query LDC. We then saw a construction of a -LDC over for based on Reed-Muller codes. The first chapter in Sergey Yekhanin‘s thesis has a nice introduction to these results.

## Student Presentation #4

*(Guest post by Swapnoneel Roy)*

*I presented the first algorithmic result in the paper Online Algorithms for Path Selection in a Nonblocking Network by Sanjeev Arora, Tom Leighton and Bruce Maggs. The algorithm was applied on a Multi-Butterfly network with inputs and outputs with the unshared neighbor property. In the algorithm, all the paths were extended from level to level (for any level ) of the network by performing the following steps:*

- every path that waits to be extended sends out a “proposal” to each of its output level neighbors in the desired direction (up or down),
- every output node that receives one proposal sends back its acceptance to that proposal,
- every path that receives an acceptance advances to one of its accepting outputs on level .

Going by this way, the algorithm extends the paths from level 0 to level . The time taken to extend the paths from one level to the next was shown to be . This makes the total running time of the algorithm .

## Student Presentations

Here is the schedule of the student presentation (all of them start at **10:30am** in Bell 224):

- Yang (Nov 17): Towards 3-query locally decodable codes of subexponential length (Yekhanin)
- Nathan+Swapnoneel (Nov 21+24): Bounds on 2-query codeword testing (Ben-Sasson, Goldreich, Sudan).
- Steve (Dec 1)
- Than (Dec 5): Approximating the Minimum Spanning Tree Weight in Sublinear Time (Chazelle, Rubinfeld, Trevisan).

Please let us know once you choose your paper and we will update the list above.

## Property Testing Lecture 3

On Friday, we started talking about property testing and in particular, testing whether the input graph (represented by a vector corresponding to its adjacency matrix) is bipartite. (The queries ask whether an edge exists between a pair of vertices in the graph.)

Before talking about the tester for graph bipartiteness, we discussed some high level connections of property testing to learning and decision tree complexity. In particular, property testing is easier than learning as it is only a decision problem (whereas a learning algorithm has to output an approximation to the function being learnt) whereas it is harder than learning as it also has to deal with inputs that are far from having the property (while learning only has to deal with functions that are from a fixed concept class). The decision tree complexity of a property is the stricter version of property testing where the tester has to determine whether the input satisfies the property or not. Graph (non)-bipartitness is a monotone graph property. The Andreaa-Karp-Rosenberg conjecture states that all monotone graph properties require any (deterministic) algorithm to probe all possible edges (this conjecture is also known as the graph evasiveness conjecture). For a quick overview of the problem and notes on a result by Kahn, Saks and Strutevant that proves the conjecture for prime number of vertices and uses topology, refer to these notes by James Lee.

We then looked at the following very natural tester for graph bipartiteness: pick a random subgraph of the input graph and accept if and only if the subgraph is bipartite. This tester obviously has perfect completeness. We saw that the naive analysis of the tester does not work well. In the next lecture, we will see a more sophisticated analysis of the soundness.

The notion of property testing was first defined in the classic paper by Oded Goldreich, Shafi Goldwasser and Dana Ron titled Property Testing and its Connection to Learning and Approximation. This paper also pioneered testing of graph properties. The tester above was first analyzed in this paper. I followed the presentation from these notes by Dana Ron. For more on property testing (especially on graph property testing) see this page by Oded Goldreich.

## Property Testing Lectures 1 and 2

In the first two lectures on property testing, we started with codeword testing. A codeword tester for a code , with query complexity , is a randomized algorithm that given an input does the following:

- If , then the tester accepts with probability ,
- If then the tester rejects with probability (where can depend on ).
- Makes at most oracle queries to .

We studied the Hadamard code , where every codeword corresponds to the evaluation vector of a linear function ( being linear implies that for every , ). This definition suggests a natural tester for the Hadamard code: think of the input from as a function , pick random inputs and accept if and only if . The tester makes only queries and obviously has perfect completeness. We saw an analysis using Fourier analysis in the lecture that showed that this tester rejects with probability at least .

The “linearity tester” above was first analyzed in a paper titled Self-Testing/Correcting with Applications to Numerical Problems by Manuel Blum, Mike Luby and Ronitt Rubinfeld. The analysis of the soundess of the tester using Fourier analysis first appeared in the paper by Mihir Bellare, Don Coppersmith, Johan Hastad, Marcos Kiwi and Madhu Sudan titled Linearity Testing in Characteristic Two. I followed the presentation from these notes by Venkat Guruswami and Ryan O’Donnell.

## Student Presentation #1

*(Guest post by Than Nguyen)*

I presented the paper by Paul Feldman, Joel Friedman and Nichloas Pippenger titled Wide-sense nonblocking networks.

*A network is an acyclic directed graph that allows connections to be made between a set of vertices, called inputs, to another disjoint set of vertices, called outputs. A network is called wide-sense nonblocking (WSNB) if a request from an idle input to an idle output can be always satisfied. This paper suggests a new way to construct “generalized concentrators” by using certain expanders. From this, they build WSNB generalized connectors with size , where is the number of inputs and outputs. In addition, with a given depth , they get a WSNB generalized connectors with size .*

## Student Presentation #5

*(Guest post by Yang Wang)*

*I presented the paper on linear time encodable and decodable code. We get a good error correcting code by using error reduction code. Because of limited time, I mainly talked about the decoding of error reduction codes. Note that the codes we talked about is a little different from usual codes in that they can be represented as bipartite graphs where the left side stands for message nodes, right side stands for check nodes and left side and right side together make up the codeword of the code. The first result was a simple explicit -regular bipartite graph where each node in the right side stands for just one check bit. We proved that this construction can reduce errors to half as long as the number of errors are bounded. The second explicit construction was more complicated. We first start with a -regular expander and then get the corresponding bipartite graph as edge vertex incident graph. Now every check node in the right side of the bipartite graph stands for several check bits and every check node together with these message node neighbors is a word of another code. In fact we used a small code and an expander to construct the error reduction code we wanted.*

* *

leave a comment