\documentclass[10pt]{article}
\usepackage{amsfonts,amsthm,amsmath,amssymb}
\usepackage{array}
\usepackage{epsfig}
\usepackage{fullpage}
\usepackage{amssymb}
\usepackage[colorlinks = false]{hyperref}
\newcommand{\1}{\mathbbm{1}}
\DeclareMathOperator*{\argmin}{argmin}
\DeclareMathOperator*{\argmax}{argmax}
\newcommand{\x}{\times}
\newcommand{\Z}{\mathbb{Z}}
\newcommand{\Q}{\mathbb{Q}}
\newcommand{\R}{\mathbb{R}}
\newcommand{\N}{\mathbb{N}}
\newcommand{\F}{\mathbb{F}}
\newcommand{\E}{\mathop{\mathbb{E}}}
\renewcommand{\bar}{\overline}
\renewcommand{\epsilon}{\varepsilon}
\newcommand{\eps}{\varepsilon}
\newcommand{\DTIME}{\textbf{DTIME}}
\renewcommand{\P}{\textbf{P}}
\newcommand{\SPACE}{\textbf{SPACE}}
\begin{document}
\input{preamble.tex}
\newtheorem{example}[theorem]{Example}
\theoremstyle{definition}
\newtheorem{defn}[theorem]{Definition}
\handout{CS 229r Essential Coding Theory}{Apr 27, 2020}{Instructor:
Madhu Sudan}{Scribe: Yash Nair}{Lecture 24}
\section{Outline: Coding for Interaction}
\begin{itemize}
\item Set up interaction and coding architecture
\item History
\item Tree Codes
\item Braverman-Rao Protocol
\end{itemize}
\section{Interaction}
We first define a framework for interaction. Consider the following dialogue:
\begin{itemize}
\item Alice says to Bob, "Please explain Fermat's Theorem"
\item Bob explains group theory, Galois theory, modular forms, and semi-stable representations to Alice
\item Alice tells Bob that she meant Fermat's \textit{Little} Theorem
\end{itemize}
The above illustrates how information can be wasted if an error occurs. Bob wasted a lot of time communicating irrelevant information to Alice: in this interactive setting, a few undetected errors can completely derail communication and interaction.
We now define the notion of an interaction.
\begin{definition}[Interaction]
An interaction is a subgraph of a rooted binary tree. Alice's input is, for every node at even depth, \textit{one} edge pointing to one of the child nodes. Bob's input is, for every node at odd depth, \textit{one} edge pointing to one of the child nodes. The 'message' corresponding to an interaction is the path of nodes traversed by following the edges of Alice and Bob's interaction.
\end{definition}
We now formally define a binary protocol of length $k$ as follows.
\begin{definition}[Binary Protocol]
Let $V = \{0,1\}^{\leq k}$, and call $V$ the \textit{stage}. Partition $V = V_A\dot\cup V_B$ into the set of vertices from which Alice communicates, $V_A$, and the set of vertices from which Bob communicates, $V_B$. Define $$E = \{(x, x0), (x,x1)| x \in \{0,1\}^{ 0$
\end{exercise}
At a high level, Schulman's protocol involves local moves on $\Pi_A$ and $\Pi_B$. After each round of communication, Alice and Bob check if they agree to ensure that no errors have occurred; however, if an error occurs, they backtrack to an agreed upon point. In contrast to this, the Braverman-Rao protocol makes global moves--instead of backtracking, Alice and Bob continue communicating without backtracking, but in a way that has changed due to their knowledge of potential error.
\subsection{Braverman-Rao Protocol}
We now describe the Braverman-Rao Protocol. Throughout, $i$ will denote the round index for Alice, and $j$, the round index for Bob.
\begin{itemize}
\item Fix tree codes $T^A$ and $T^B$. They need not be the same, but both Alice and Bob have access to the other's tree code.
\item We now describe Alice's protocol:
\begin{itemize}
\item Maintain a sequence of edges $(e_1...e_i) = S_A\subset \Pi_A$ of her own edges. These are the edges that Alice has told Bob about. Then at each round, Alice compresses this sequence (we describe this later), encodes with $T^A$, and sends the new bits to Bob
\item At round $j$:
\begin{itemize}
\item Alice receives $m^B_j$ from Bob, and combines with past messages to get $m^B_{\leq j}$
\item Alice brute force decodes $m^B_{\leq j}$ to get $R_{B,j}$ (where, here, by decoding, we mean that Alice finds the $R_{B,j}$ that minimizes $\Delta(m^B_{\leq j}, T^B(R_{B,j}))$)
\item If $R_{B,j}$ seems like Bob is suggesting to take irrelevant edges based on his previous choices, or he suggests to take both edges out of the same node, ignore the transmission and move on to the next stage
\item Otherwise, if the next edge $e$ that Alice wants to take after following the unique path in $S_A \cup R_{B,j}$ is not in $S_A$, then add $e_{i+1} \gets e$ to $S_A$
\end{itemize}
\item Send $(i+1)$th bit of $T^A(S_A)$ to Bob
\item Repeat the above for $n$ steps
\item If the above determines a path in $(\Pi_A, \Pi_B)$, return it.
\end{itemize}
\end{itemize}
In the above, the question remains of how we can efficiently compress writing an edge without needing $k$ bits (to specify the child node, for example). Notice that we add edge $e_i$ only if Alice had previously added $e_j$ to $S_A$. Thus, we can encode $e_i$ as $(j, b_1,b_2)$ where $b_1$ indicates the edge that Bob took from the tail of $e_j$, and $b_2$ indicates that edge that Alice takes from there. Since $|S_A| = O(k)$ it takes $O(\log k)$ bits to describe $j$, and thus using this compression it takes only $O(\log k)$ bits to write transmit an edge. To get even better compression, we only need send $(i-j, b_1, b_2)$, since both players know the round number, $i$. The advantage here is that $i-j$ is typically constant (in expectation). We now give a high-level overview of the analysis of this protocol.
\subsection{Analysis of Braverman-Rao Protocol}
At a high level, we will measure progress by $S_A$ and $S_B$, asking how far down the correct path (given by $\Pi_A\cup \Pi_B$) $S_A\cup S_B$ gets. The strength of the Braverman-Rao construction, in that it does not erase progress is, that progress can never decrease. In particular, we may ask, when the path length given by $S_A\cup S_B$ is $i$, and Alice has just added the $i$th edge to $S_A$, why Bob does not add the $i+1$th edge. The only thing preventing Bob from adding the $i+1$th edge is the errors of the adversary. But since the adversary is limited in its errors, if Alice and Bob keep communicating, Bob will eventually add the $i+1$th edge to $S_B$. There will be a constant number of steps between path length being $i$ and path length being $i+1$ due to the fact that the $i+1$th edge must be communicated and the number of errors that the adversary has introduced.
With this high-level overview, we give a summary of the analysis in Braverman-Rao. First, they introduce three key definitions:
\begin{definition}
Define $N(i,j)$ to be the number of errors between the $i$th and $j$th rounds of communication. Define $m(i)$ to be the length of the prefix in $\Gamma_A\cup \Gamma_B$ agreed upon by Alice and Bob after $i$ transmissions in $\Gamma_A\cup\Gamma_B$. Finally, define $t(i)$ to be the first time that the $i$th edge enters $S_A$.
\end{definition}
With these definitions, Braverman and Rao prove three claims; we give some intuition for each:
\begin{itemize}
\item $m(n) \geq t(k)$. This is due to the fact that an error case (i.e. $f_A(a) \neq f_B(b)$) only occurs when $m(n) < t(k)$.
\item $m(t(i) - 2) < t(i-1)$. The intuition for this statement is that a disagreement on the $i$th edge is due to a prior inconsistency which occurred before the $(i-1)$th edge was announced.
\item $N(m(i)+1, i) \geq \delta (i - m(i))/2$. Intuitively, this claim states that the inconsistency is contributed by the error.
\end{itemize}
These three claims together imply that the Braverman-Rao protocol corrects $\delta/2$ fraction errors.
\subsection{Constructability}
Notice that none of the above protocols are constructive. In fact, the constructability of tree codes would imply that of the Schulman protocol which would imply that of the Braverman-Rao protocol. Thus, we do not yet have deterministic efficient protocols nor an explicit construction of a tree code.
\end{document}