% -----------------------------*- LaTeX -*------------------------------

\documentclass[12pt]{report}

\usepackage{scribe, epsfig}



\newtheorem{defin}{Definition}

\newtheorem{thm}{Theorem}

\newtheorem{lem}{Lemma}

\newcommand{\epb}{$\epsilon\mbox{-biased\ }$}



\begin{document}



% \course{MIT 18. 996}                  % optional

%\coursetitle{Topic in TCS: Internet Research Problems}

% \semester{Spring 2002}                        % optional

\lecturer{Madhu Sudan, Ravi Sundaram}           % required

\scribe{Nicole Immorlica, Vahab S. Mirrokni}            % required

\lecturenumber{5}                       % required, must be a number

\lecturedate{March 6}           % required, omit year



\maketitle



% ----------------------------------------------------------------------

%\vspace{2cm}

%\begin{center}

%{\Huge Guessing Secrets}

%\end{center}

\vspace{0.5cm}

\begin{center}

%\begin{flushright}

\small\sffamily\slshape

Listen, Do you want to know a secret,\\

Do you promise not to tell, whoa oh, oh.\\

Closer, Let me whisper in your ear,\\

Say the words you long to hear...\\

\begin{flushright}

\textup{--- Beatles, \\February 11, 1963}

\end{flushright}

\end{center}

\vspace{1cm}

\section{Motivation}



Today, we will discuss issues that arise in DNS.  First, let's review the

DNS mechanism.



\begin{figure}[h]

\begin{center}

\includegraphics[scale=0.66]{photo.eps}

%\vspace{2cm}

\end{center}

\caption{the DNS mechanism}

\label{fig}

\end{figure}



Akamai has thousands of webservers which cache the foo.com web page, and

the goal of Akamai's authorative nameserver is to distribute the foo.com

load somewhat evenly among these webservers.  As nameservers cache IP

addresses, each nameserver will direct all its clients to the same IP

address.  Thus each nameserver drags a load proportional to the number

of its clients.  However, we do not know the number of clients of a

given nameserver.  Furthermore, it is not enough to simply count the

number of clients because some clients have more load than others.  What

we would really like is to find a mapping of nameservers to clients.

To complicate matters, we must remember that a client may use more

than one nameserver.



Let's review the information we are given.  Akamai's authorative

nameserver knows the IP addresses of all the nameservers that submit

foo.com queries.  The Akamai webservers know the IP addresses of all the

clients that request the foo.com webpage.  Now how can we discover which

clients were directed to each webserver by which nameserver?

\begin{enumerate}





\item IP addresses in the same block



Perhaps we can assume that clients use nameservers whose IP addresses

are in the same block as their own.  As IP addresses in the same block

tend to be geographically close, this assumption seems reasonable.

However, it is unfortunately just not true.



\item Direct each nameserver to a unique webserver and see which clients

show up



Clearly this approach works, but there are a myriad of implementation

problems.  The first major problem is that there are many more

nameservers than webservers.  Of course, we can try to sidestep this

obstacle by repeating this procedure several times, keeping track of the

set of clients at each webserver, taking some intersections, etc.

Another major problem is that clients aren't continously requesting

foo.com content, so in each iteration of this procedure, Akamai must

wait a while to see all the clients that show up.



\item Dynamically create a ``fake'' link that encodes client IP on the

foo.com webpage



In this solution, the Akamai webserver dynamically adds a one pixel gif

to the foo.com webpage with the web address 

%<client ip>.foo.com

client.foo.com.  As the

client renders the webpage, it will make another request to its

nameserver for the IP address of 

%<client ip>.foo.com

client.foo.com.  When its

nameserver asks Akamai's authorative nameserver to resolve this address,

the authorative nameserver can associate this client to this

nameserver.



This solution solves our problem and appears to work even though it

creates a bit of additional traffic.  However, each nameserver now needs

to make a unique query for every of its clients.  Even if the

time-to-live of the reply is zero, some faulty nameserver

implementations will try to cache all these unique queries.  This floods

the cache of the nameserver, and, in some cases, actually crashes the



nameserver.  While this may appear to be the nameserver's problem,

Akamai needs to market its solutions and it is hard to market a solution

that breaks existing albeit faulty infrastructure.



\item Statically force a client to reveal each bit of its nameserver's

IP address



In this solution, Akamai adds $32$ one pixel gifs to the foo.com webpage

with the addresses $i$.foo.com for $0\leq i < 32$.  Akamai also

designates $64$ webservers, $i_j$ for $0\leq i < 32$, $j\in\{0,1\}$, to

host the one pixel gifs.  The Akamai authorative nameserver answers a

query for $i$.foo.com with webserver $i_j$ where $j$ is the $i$th bit of

the IP address of the questioning nameserver.  By observing which of the

$64$ webservers a client visited, we can now reconstruct the client's

nameserver's IP.

% vahab - mention what we are really doing in this solution is asking

% the client 32 yes/no questions about his secret - his nameserver's ip

% address.  also, if a client has more than 2 nameservers, doesn't

% madhu's algorithm misguide us?  if so, why is it so much better than

% this algorithm?  i mean, 2 isn't much bigger than 1.



This solution solves the problems of the last solution because now each

nameserver will cache just a constant number (i.e. $32$) of IP

addresses, namely $i$.foo.com for $0\leq i < 32$.  However, this

solution no longer solves our problem when a client uses more than one

nameserver.



\end{enumerate}



\section{Problem Statement}

Notice in the last solution, what we are really doing is asking the client

$32$ yes/no questions about its nameservers' IP addresses.  Namely, we

ask $32$ questions of the form ``What is the $i$th bit of your

nameserver's IP address?''.  The client then selects one of its

nameservers and answers our question truthfully.  But this strategy

fails to give us any information if the client has more than one

nameserver.  For example, if the client had a nameserver with an

all-zeros IP address and a nameserver with an all-ones IP address, he

could answer our $32$ questions in any of the $2^{32}$ possible ways.

Thus this strategy allows us to reach no conclusion regarding its

nameservers' IP addresses.  In this section, we will extend this

strategy by asking more questions.  In this way, we hope we will be able

to conclude more information about the possible nameservers of the

client.



First we give a formal definition of our problem:



\begin{defin}

{\em The Guessing Secrets Problem:} 

Alice (the adversary) has a set $S=\{X_1, \ldots, X_k\}$ of $k$

secrects, taken from a universe $\Omega$ of size $N$.  Bob asks Alice a

series of ``questions'' $\{F_i|F_i:\Omega \rightarrow \{0, 1\}\}$. For

each $F_i$, Alice selects some $X_i\in\Omega$ and returns

$\{F_i(X_i)\}$.  Bob then outputs a set $G$ of sets of secrets which is

its guess concerning the possibilities for the set $S$.

%The job of Bob is to select questions so as to determine as much about the 

%secrets as efficiently as possible.

% -- efficiency is not part of the definition

\end{defin} 



There are two kinds of strategies for Bob, namely {\em adaptive} and 

{\em oblivious}. 

\begin{defin}

In an {\em adaptive} strategy, Bob can design questions based on previous 

answers. In this case, Bob first asks question $q_1$ and Alice answers $a_1$.

Then Bob asks question $q_2$ and Alice answers $a_2$ and so on. 

\end{defin}

\begin{defin}

In an {\em oblivious} strategy, all of Bob's question must be asked in

advance of any of Alice's answers. Now, Bob asks $q_1, q_2, \ldots, q_m$

and Alice then answers all of them $a_1, a_2, \ldots, a_m$.

\end{defin}



In this definition, Alice corresponds to the client, its nameservers,

and Akamai's authorative nameserver.  Alice's secrets correspond to her

nameservers' IP addresses.  Bob corresponds to Akamai's webservers.  The

questions of an oblivious Bob are embedded as links in the original

foo.com webpage and the answers are computed by Akamai's authorative



nameserver upon queries from the client's nameservers.  An adaptive Bob

can also be implemented in this setting by embedding the link for

question $q_i$ in the page for question $q_{i-1}$.



We say Bob has solved the guessing secrets problem if he has learned as

much as is theoretically possible concerning $S$.  Observe that Bob can 

never hope to learn with certainty more than one of Alice's secrets,

since Alice can always answer every question using the same $X_i$.  We

can in fact completely characterize the amount of information Bob can

hope to learn about $S$, but first we will develop a model of this

problem.



\begin{defin}{\em The Graph Model:}

Let $K_N$ denote the complete hypergraph with edge sets of size $k$ on

the set of $N$ vertices of $\Omega$. A set of secrets $S=\{X_1, \ldots,

X_k\}$ corresponds to an edge $(X_1,\ldots,X_k)$ of $K_N$.  Each

question $F_i:\Omega \rightarrow \{0, 1\}$ partitions the vertices of

the graph into two sets, $F_i^{-1}(0)$ and $F_i^{-1}(1)$.

\end{defin}

Notice in this model, an answer $b\in\{0,1\}$ to the

question $F_i$ implies at least one of the $X_i\in S$ are in

$F_i^{-1}(b)$.  Thus all edges in $F_i^{-1}(1-b)$ can be

eliminated as possibilities for the set of secrets.  Therefore, no

matter how adversarial Alice acts, Bob can always ask questions that

will reduce the resulting graph to a set of intersecting edges (i.e. a

{\it star} or a {\it triangle} for $k=2$), for if there were disjoint

edges Bob could add a question which separates the edges and thereby

eliminate one of them.  Furthermore, Bob can not hope to learn more than

this.

% is there an easy way to see this?



Now we can say formally that Bob solves the guessing secrets problem if

he returns an intersecting set of edges $G$ whose union contains $S$.

%intersecting set of edges $G$ that contain $S$.

 We call a

strategy of Bob that returns an intersecting set for any adversary a

{\it separating} strategy, and the set of edges returned a {\it

surviving} set.



\section{Solutions}



Clearly oblivious and adaptive separating strategies do exist.  For

example, Bob can simply ask the $O(N^k)$ questions corresponding to all

cuts which separate one edge from the rest of the graph.  However, this

strategy is a bit discouraging because the information we are trying to

learn is of size $O(k\log N)$.  In order for our strategy to be

considered {\it efficient}, we would like to ask just poly$(k,\log N)$

questions each of size poly$(k,\log N)$.  Furthermore, in order to

recover the surviving set from Alice's questions, Bob must spend

$O(N^k)$ computation time (list all $k$-sets and eliminate inconsistent

ones).  In order for our strategy to be considered {\it invertible}, we

would like to be able to recover the surviving set in just poly$(k,\log

N)$ time.



But just how efficient a strategy can we design?  In \cite{CGL}, Chung

et al. proved the following theorems for the case with $k=2$ secrets:



\begin{thm}

Let $f(N)$ be the smallest number of questions Bob must ask in an

adaptive separating strategy for an initial set $\Omega$ of size

$N$. Then, 

$$3\log_2(N)-5\le f(N)\le 4\log_2(N)+3, \mbox{\ for\ } N>2 $$

\end{thm} 



\begin{thm}

Let $f(N)$ be the smallest number of questions Bob must ask in an

oblivious separating strategy for an initial set $\Omega$ of size

$N$. Then, 

$$f(N)\le (c+o(1))\log_2 N$$ 

where $c=3/\log {8\over 7}=15.57\ldots$.

\end{thm}



The proofs of the upper bounds in these theorems either

use the probabilistic method (and thus are non-constructive) or

construct strategies that have large question sizes and not invertible.

Chung et al. explicitly construct several strategies, but they are all

less than optimal in some sense.  Recently, Micciancio et

al. \cite{MS01} presented an adaptive strategy with the optimal $O(\log



N)$ questions and an $O(\log^2 N)$ time algorithm for recovering $k=2$

secrets.



Today, we will see a result published by Alon et al. \cite{AGKS} that

gives an invertible oblivious strategy with the optimal $O(\log N)$

questions for $k=2$ secrets.  This strategy depends heavily on

error-correcting codes.  To motivate the use of error-correcting codes



in problems like guessing secrets, we first present a similar problem

{\em 20 questions}, and solve it with error-correcting codes.



\subsection{20 questions with a liar}

In the 20 questions game a player, Bob, tries to discover the identity

of some unknown secret drawn by a second player, Alice, from a large

space of $N$ secrets. Bob is allowed to ask Alice binary (Yes/No)

questions about the secret. Alice answers each question truthfully

according to her secret. The goal of Bob is to learn the secret by

asking as few questions as possible. If the $N$ possible secrets are

associated with $\lceil \log N \rceil$-bit strings, then clearly $\lceil

\log N \rceil$ questions are both necessary and sufficient to discover

the secret.  The guessing secrets problem is a generalization of this

game in which Alice picks not one, but $k$ secrets, and answers

questions truthfully according to a secret of her choice.



There is another way of generalizing 20 questions game.  In this

generalization, Alice again has just one secret $x$, but she is allowed

to lie, say, 10\% of the time.  Equivalently, we can pretend Alice

always answers truthfully, but she transmits her answers through a noisy

channel which corrupts 10\% of the bits.  Error-correcting codes are an

obvious solution to this problem.  Bob can pick an appropriate code $C$

with encoding function $E$ and decoding function $D$.  He asks Alice

about each bit of $E(x)$.  The resulting string $E(x)$ will be a

codeword with at most 10\% error in it. Thus, if Bob uses an

error-correcting code with error recovery better than 10\%, then he can

recover the secret $D(E(x))$.  Luckily for Bob, we know of codes that

can correct strings with less than 50\% error.



We would like to apply the same approach to the guessing secrets

problem.  We consider one secret $X_1$ as the ``true'' secret, and all



other secrets as lies.  We then try to apply Bob's error-correcting code

strategy.  However, there is a problem.  Namely, even with just two

secrets, Alice can lie 50\% of the time if we don't pick our code

carefully.  Clearly, there are no error-correcting codes with 50\% error

recovery.  But, we have a stronger assumption than in the liar game.

Alice's lies must be consistent!  That is, Alice's lies are just bits of

$k-1$ other codewords.  We will use this fact to define a class of

codes, and encoding and decoding strategies for these codes.



\subsection{Separating codes}

We will concern ourselves with the 2-secret guessing problem

(i.e. $k=2$).  For each secret $x\in \Omega$, we denote the sequence of

answers to the questions $F_i$ on $x$ by 

$$C(x) =\langle F_1(x), F_2(x), \ldots, F_n(x)\rangle.$$

We call the mapping $C:\Omega\rightarrow \{0, 1\}^n$

thus defined as the code used by the strategy. There is clearly a

one-one correspondence between oblivious strategies $\{F_i\}$ and such

codes $C$ (defined by $F_i(x) = C(x)_i$, where $C(x)_i$ is the $i$'th

bit of $C(x)$). Now we can refer to a strategy using its associated code

$C$. We say that a code $C$ is {\em $(2, 2)$-separating} if for every

$4-tuple$ of distinct secrets $a,b,c,d\in \Omega$, there exists at least

one value of $i$, $1\le i\le n$, called the {\em discriminating index},

for which $C(a)_i= C(b)_i \not = C(c)_i = C(d)_i$.  Note that if Bob

asks questions according to a separating code $C$, then for every two

disjoint pairs of edges $(a,b)$ and $(c,d)$, Bob can rule out one of

them based on the answer which Alice gives on the $i$'th question, where

$i$ is a discriminating index for the $4$-tuple $(a,b,c,d)$. In fact it

is easy to see that the $(2,2)$-separating property of $C$ is also

necessary for the corresponding strategy to solve the 2-secrets guessing

game. Thus, there exists a $(2,2)$-separating code $C: \Omega\rightarrow

\{0, 1\}^n$ if and only if there exists an oblivious strategy for Bob to

solve the 2-secret guessing problem.  Now all that remains is to find

good $(2,2)$-separating codes. We use the following theorems and

definitions to design such codes efficiently:



\begin{thm}

\label{22sep}\cite{AGKS}

Let C be an $[n, m]_2$ binary linear code with minimum distance $d$ and

maximum distance $m_1$. Assume further that $d, m_1$ satisfy the

condition $d>{3m_1\over 4}$. Then, $C$ is a $(2, 2)$-separating code.

\end{thm}



\begin{defin}

A binary linear code of block length $n$ is an \epb code if every

non-zero codeword in $C$ has Hamming weight between $({1\over

2}-\epsilon)n$ and $({1\over 2} + \epsilon)n$.

\end{defin}



From above theorem and definition, one can easily conclude that if a

binary linear code $C$ is \epb for some $\epsilon\le {1\over 14}$, then

$C$ is $(2,2)$-separating.  A simple explicit construction of \epb codes

can be obtained by concatenating an outer Reed-Solomon code with



relative distance $(1-2\epsilon)$ with an inner binary Hadamard

code. However, this and other similar constructions encode our strings

of length $\log N$ into codewords of length $O({\log^2

N\over\epsilon^2})$, more than the desired $O(\log N)$ length.

%But, there are also known ways to achieve \epb codes with block length

%$O({m\over \epsilon^{O(1)}})$.  For example, we can use a concatenated

%scheme with outer code any explicitly specified specified code with

%relative distance $(1-O(\epsilon))$ over a constant alphabet size (that

%depends on $\epsilon$), and inner code as a Reed-Solomon concatenated

%with Hadamard code. 

However, in \cite{ABN} Alon et al. proved:



\begin{lem}

For any $\epsilon >0$, there exists an explicitly specified

$[O(\frac{m}{\epsilon^3}),m]_2$ family of  \epb codes.

\end{lem}



Since the codes from this lemma have constant rate, we see that there is

an explicit oblivious strategy for the 2-secrets guessing game that uses

$O(\log N)$ questions.  The problem of above method is that it is not

invertible. Next we will design an invertible strategy that recovers

secrets in poly($\log N$) time.



\subsection{List Decoding}

Again, we consider the 2-secrets guessing game (i.e. $k=2$).



\begin{thm}



\label{ld}

Suppose that $C$ is a $[cm,m]_2$ binary linear code which is \epb for

some constant $\epsilon <{1\over 14}$. Suppose further that there exists

a list decoding algorithm for $C$ that corrects up to a ${1\over

4}+{\epsilon \over 2}$ fraction of errors in time $O(T(m))$. Then, $C$

is $(2,2)$-separating code that gives a strategy to solve the $2$-secrets

guessing game for a universe size of $N=2^m$ in $O(T(\log N) +\log^3 N)$

time using $c\log N$ questions. 

\end{thm}



\begin{proof}[Sketch] Suppose Bob uses the code $C=[n\equiv cm,m]_2$

mentioned above for his strategy.  If Alice's secrets are $\{X_1, X_2\}$

and her answers to Bob are ${\bf a} = (a_1, a_2, \ldots, a_n)$, then for

each $i$, we must have either $C(X_1)_i = a_i$ or $C(X_2)_i=a_i$.  As

$C$ is \epb, $C(X_1)$ and $C(X_2)$ must agree in at least $({1\over

2}-\epsilon)n$ coordinates.  Furthermore, since Alice doesn't lie, at

least half of the $({1\over 2}+\epsilon)n$ remaining coordinates must

agree with one of the codewords, say $C(X_1)$.  This means ${\bf a}$ has

a Hamming distance of at most $({1\over 4}+{\epsilon\over 2})n$ from

$C(X_1)$.



To recover the secrets, Bob should,



\begin{enumerate}

\item Perform list decoding of the code $C$ using the assumed algorithm

to find the set 

$$S=\{x\in \{0, 1\}^m|\Delta({\bf a}, C(x))\le ({1\over 4}+{\epsilon\over

2})n\}$$

where $\Delta(x,y)$ denotes the Hamming distance between $x$ and $y$.



\item For each $x\in S$, let $A$ be the set of coordinates where $C(x)$

and ${\bf a}$ agree.  Find the set of possible matching secrets $S_x$

by setting the coordinates $A$ of ${\bf a}$ to variables and

finding all solutions $x'$ to the linear system of equations $C(x')={\bf

a}$ (this is a linear system because $C$ is a linear code).  If $S_x$ is

empty (i.e. there is no $x'$ such that Alice could have answered ${\bf

a}$ with secrets $(x,x')$), then remove $x$ from $S$.  Otherwise,

represent $S_x$ by a set of basis vectors.



\item Return the set $G=\{\{x, x'\}: x\in S, x'\in S_x\}$ as the guess.

\end{enumerate}



Notice a set of secrets $\{x,x'\}$ is in $G$ if and only if it is

consistent with the answer ${\bf a}$, so in particular Alice's real

secrets $\{X_1,X_2\}\in G$.  Furthermore, as $\epsilon <{1\over 14}$,

theorem~\ref{22sep} implies $C$ is $(2,2)$-separating and therefore $G$

is an intersecting family.  This shows the correctness of Bob's

strategy.



The efficiency of the inversion follows as list decoding returns a

constant number of solutions, so we must solve just a constant number of

linear systems.  Furthermore, due to our clever representation of $S_x$,

our output is polynomial in $\log N$ even when the number of vertices in

our intersecting family is $O(N)$ (e.g. the star with $(N-1)$ non-hubs

obtained when ${\bf a}=C(x)$ for some $x$).

\end{proof}



For detailed proof of correctness and analysis of this algorithm, see

\cite{AGKS}.  Also, notice if you don't believe theorem~\ref{22sep},

you can use the naive graph-cut approach on the constant-sized set $S$

of vertices returned by the list decoding.  To implement this so that



the strategy remains oblivious, assign an ordering to the secrets $S$

output by the list decoding algorithm.  Consider the complete graph

$K_{|S|}$ on $|S|$ vertices.  For every pair of vertices $i$ and $j$ in

$K_{|S|}$, Bob asks Alice ``If you use my list decoding algorithm, is

your secret in the set $\{i,j\}$?''  Bob then eliminates edges in

$K_{|S|}$ as discussed.  If both of Alice's secrets are in $S$, then

the result of this algorithm will be a star or a triangle.  If just

one of her secrets is in $S$, then the result of the algorithm will be

a star and {\it not} a triangle.  Thus, if the result is a triangle,

returning the triangle will give a correct solution $G$.  If the result

is a star, we can not tell if just one or both secrets are already in

the star.  However, extending the star to the whole set $\Omega$ will

give a correct solution $G$.



The only remaining problem is to prove the existence of the \epb codes

used in theorem~\ref{ld}.  The existence of such codes is a standard

result of coding theory.



\begin{theorem}

For every positive constant $\alpha < 1/2$, the following holds. For all

small enough $\epsilon>0$, there exists an explicit asymptotically good

family of binary linear \epb codes which can be list decoded up to an

$\alpha$ fraction of errors in $O(n^2({\log(n) \over \epsilon})^O(1))$

time. 

\end{theorem}



A sketch of this result may be found in \cite{AGKS}.



\section{Open Questions}



There are numerous questions about the guessing secrets problem that

remain open, most of which involve some generalization or restriction of

the problem.  We conclude with a list some of the open questions.



\begin{enumerate}

\item{$k$-Secret Guessing Problem}



In the last two sections, we analayzed strategies for $k=2$ secrets.  A

natural question is to analyze the case for $k>2$.  Note that the list

decoding solution no longer works because Alice's answer may be quite

far from the codewords of her secrets.  The hypergraph model

and accompanying naive algorithm show that strategies do exist for

$k>2$.  But, as stated, the naive strategy is impractical.  We do have

some negative results for this problem.  In particular, Alon et

al. showed~\cite{AGKS} oblivious strategies require at least

$\Omega(2^{2k}\log N)$ questions and adaptive strategies require at

least $a_k\log N - a_k\log a_k$ questions where

$$a_k=2k-2+\frac{1}{2}{{2k-2}\choose {k-1}}.$$

Furthermore, they present an efficient (but not invertible) oblivious

strategy for this problem based on $2k$-universal families of binary

strings that uses at most $ck2^{6k}\log N$ questions for some constant

$c$ independent of $k$.



\item{Relax Solution Condition}



We can consider a restricted form of the problem in which we only

require Bob to return a guess set $G$ such that any $k$-set of secrets

$S$ that is consistent with Alice's answers intersects $G$ in at least

one element~\cite{AGKS}.  In this case, there is an efficient invertible

oblivious strategy for Bob based on concatenated codes and the same list

decoding ideas presented here.  It may be possible to improve this

result, and algorithms for adaptive strategies should be studied.



\item{Non-binary Questions}



Another way to generalize our problem is to allow Bob to ask questions

with more than two answers.  Clearly, this makes the problem much easier

for Bob.  For example, in the $2$-secret problem, Bob can now always

determine at least one of Alice's secrets (he can eliminate triangles by

asking a tertiary question).  However, it is not known how non-binary

questions affect the problem for $k>2$.



\item{Fixed Number of Rounds}



We can also restrict the problem by allowing Bob only a fixed number of

rounds in the adaptive case.  If we allow Bob to ask more than one

question per round, this problem becomes a sort of hybrid between the

oblivious and adaptive strategies.  How can we combine the solutions for

oblivious and adaptive strategies to get an optimal strategy in this

case?





\item{Lying}



Finally, we can allow Alice to lie some fraction of the time.  That is,

for say 10\% of the questions, Alice can give any answer she chooses,

independent of her secrets.  Can we find codes such that this new power

doesn't help Alice too much?  How about in the adaptive case?



\end{enumerate}





\begin{thebibliography}{AAM9}



\bibitem{ABN} {\sc N. Alon, J. Bruck, J. Naor, M. Naor, and R. Roth.}

{\it Construction of asymptotically good low-rate error-correcting codes



through pseudo-random graphs.}, IEEE Trans. Info. Thy., 38(2):509--512,

March 1992.



\bibitem{CGL}  {\sc Fan R. K. Chung and Ronald Graham and Frank Thomson

Leighton}, {\it Guessing Secrets}, Symposium on Discrete Algorithms,

p723-726, 2001.



\bibitem{AGKS}  {\sc Noga Alon, Venkatesan Guruswami, Tali Kaufman,

Madhu Sudan}, {\it Guessing Secrets Efficiently via List Decoding}, SODA

2002.



\bibitem{MS01} {\sc Daniele Micciancio, and Nathan Segerlind.} {\it

Using prefixes to efficiently guess two secrets.}, Manuscript, July



2001.

\end{thebibliography}



%\begin{danger}

%That's dangerous.

%\end{danger}

%

%\section{Challenges in Internet Ages}

%

%The internet can be too slow. 

%The following Theorem showed that we can always speedup the internet.

%

%\begin{theorem}

%If the current internet configuration yields average access speed $s$, then there is

%another internet configuration that yields average access speed at least $2s$.

%\end{theorem}

%

%\begin{proof}[folklore]

%By applying Akamai Technologies,

%\begin{equation}

%\hat{s} = \sum_{i=1}^{\infty}  \hat{s}_i \ge 2s

%\end{equation}

%Therefore the theorem is true.

%\end{proof}

%

%Therefore, we can put much junks on internet as possible!!!!

%

%\begin{ddanger}

%Really really dangous!!!

%\end{ddanger}

%

%\subsection{Information Searching is Hard}

%

%Google is very powerful, but it still returns too much information on a query.

%

%

%\begin{table}[htop]

%\centerline{

%    \begin{tabular}{|l|lr|}

%       \hline

%       \textbf{Query Type/Expectation} & Low & High \\

%       \hline

%       Single Key Word     & Fast/Fun & Too much junks \\

%       Logical Expression & Better/Happy & Lots of work/little benefit\\

%       Really Smart Query   & Kick Ass/Owa!! & Kick Ass/Happy \\

%       \hline

%    \end{tabular}}

%\caption{Internet Psychology. }

%\end{table}

%

%So life is hard.

%

%\subsection{How Much Disk Space Do We Need? }

%

%The internet is getting faster and faster, and the information junks is getting 

%more and more. Does that imply that we should invest in companies that produce 

%hard disks.

%

%

%\begin{corollary}

%There is a constant $\lambda > 1$ such that if the internet speedy doubles, then

%the amount of disk spaces needed to support the internet increases by a factor of $\lambda$ \qed

%\end{corollary}

%

%But which company shall we invest in?

%

%\vfill

%\begin{flushright}\small\sffamily\slshape

%Predication is hard, especially about future....\\{}

%[Invest in as many promising hard disk companies as possible]\\

%\textup{--- Wall Street Analyst, \textsl{New York City} (Jan. 2000)}

%\end{flushright}

%

\end{document}









