\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}}}
\newcommand{\EE}{\mathcal{E}}
\renewcommand{\bar}{\overline}
\renewcommand{\epsilon}{\varepsilon}
\newcommand{\eps}{\varepsilon}
\newcommand{\DTIME}{\textbf{DTIME}}
\renewcommand{\P}{\mathbb{P}}
\newcommand{\SPACE}{\textbf{SPACE}}
\newcommand{\wt}{\operatorname{wt}}
\newcommand{\bern}{\operatorname{Bern}}
\newcommand{\unif}{\operatorname{Unif}}
\begin{document}
\input{preamble.tex}
\newtheorem{example}[theorem]{Example}
\theoremstyle{definition}
\newtheorem{defn}[theorem]{Definition}
\theoremstyle{remark}
\newtheorem*{sol}{Solution}
\handout{CS 229r Essential Coding Theory}{Apr 27, 2020}{Instructor:
Madhu Sudan}{Scribe: Junu Lee}{Lecture 24}
\section{Today}
\begin{itemize}
\item Coding for Interactions
\begin{itemize}
\item Setup: Interactions and Coding Protocols
\item History
\item Tree Codes
\item Braverman-Rao Protocol (2011)
\end{itemize}
\end{itemize}
\section{Interactions}
An interaction can be thought of as a conversation between two entities (named ``Alice'' and ``Bob''). As with any conversation, an error caused by a misunderstanding can derail a conversation. For example, consider the following exchange:
\begin{quote}
Alice: ``Please explain the proof of Fermat's [unintelligible] Theorem.'' \\
Bob: \:$^*$spends four lectures going over group theory, Galois groups, semi-stable representations$^*$ \\
Alice: ``I said Fermat's \textit{Little} Theorem''.
\end{quote}
It seems quite possible for some adversary to make keywords of these sentences unintelligible, making communication much more inefficient. We formalize this idea of this communication, called an \textit{interaction}, and discuss ways to protect interactions against adversaries that may change the communicated subject between Alice and Bob.
\subsection{Definitions}
Before we delve into the formal mathematical definition, we give the intuition for how we view a conversation. Define the graph $(V,E)$ as a rooted binary tree with length $k$, i.e. $V = \{0,1\}^k$ and $E = \{(x, x0), (x,x1) \mid x \in \{0,1\}^{ 0$ exist.
\end{exercise}
%Both the Schulman and Braverman-Rao papers use tree codes in their encoding scheme. Schulman uses them
\section{The Braverman-Rao Protocol}
Braverman and Rao utilize tree codes in their 2011 result, which was described above. We give the protocol in more detail. We fix tree codes $T^A$, $T^B$ (which are not necessarily identical). Then Alice's protocol is the following:
\begin{itemize}
\item Let her \textit{state} be some sequence $S_{A} = (e_1, \dots, e_i) \subseteq \Pi_A$ of edges she has communicated up until her $i^{th}$ round of communication.
\item In the $j^{th}$ round of communication:
\begin{itemize}
\item Alice receives message $m_j^B$, which she appends to a running sequence $m_{\le j}^B$.
\item She decodes to a sequence $R_{B,j} = \argmin \delta(m_{\le j}^B, T^B(R_{B,j}))$. This can be computed through brute force.
\end{itemize}
\item Let $e$ be the successor to the path $R_{B,j} \cup S_{A}$.
\begin{itemize}
\item If $e$ is not in $S_{A}$, then $S_{A} \xleftarrow[]{} S_A$ appended by $e$.
\item If else, do nothing.
\end{itemize}
\item Send the newest bits of $T^A(S_{A})$ to Bob (i.e. $T^A(S_{A}) \setminus T^A(S_{A})$).
\item We repeat the above for $n$ steps. After $n$ rounds, if there is a path from root to leaf in $R_{B, n} \cup S_A$, let this be Alice's output.
\end{itemize}
The analogous follows for Bob, who then outputs his path. If they match, we output it as our valid transcript.
\subsection{Compression}
For Alice and Bob to efficiently communicate, we cannot afford to have them send the encodings of $S_A$ and $S_B$ explicitly across the channel for every round. This leads to $O(n^2)$ total bits sent (treating the rate of the tree code as constant). We have two ideas for compression.
First, if we were to append $e_i$ to $S_A$, then at some point previously we must have presented edge $e_j$ such that it led Bob to communicate an edge whose head is the tail of $e_i$. Thus, to Bob, $j$ restricts $e_i$ to at most four possibilities. Two bits $b_1b_2$ are enough to specify which of these four is $e_i$. Thus, communicating $e_i$ as $(j, b_1b_2)$ achieves $\log n$ compression, giving us a total of $O(n\log n)$ bits communicated.
However, we can do better. In general we expect $i-j$ to be small, so instead of communicating the pair $(j, b_1b_2)$, we may communicate the pair $(i-j, b_1b_2)$. Overall, we achieve near-linear performance.
\subsection{Analysis}
We provide a brief highlight of the analysis used by Braverman and Rao to prove the correctness of the algorithm. First, we define some notation:
\begin{itemize}
\item $N(i,j)$ is the number of errors during transmissions $i$ to $j$.
\item $m(i)$ is the length of prefix in both $\Gamma_A$ and $\Gamma_B$ agreed upon after $i$ transmissions.
\item $t(j)$ is the first time that the $j^{th}$ edge enters $S^A$ and is announced to Bob.
\end{itemize}
From this we have three lemmas from Braverman and Rao that prove correctness. The proofs are found in their paper, but we provide a bit of logical intuition for why these statements hold true.
\begin{lemma}[Key Lemmas]
\mbox{}
\begin{enumerate}
\item[(1)] $m(n) \ge t(k)$
\begin{itemize}
\item If we ever get the error $f_A(a) \neq f_B(b)$, then we know that $m(n) < t(k)$.
\end{itemize}
\item[(2)] $m(t(i)-2) < t(i-1)$
\begin{itemize}
\item If Alice and Bob have not agreed on the $i^{th}$ edges, then they must have had miscommunication in the time prior to announcing the $(i-1)^{th}$ edge.
\end{itemize}
\item[(3)] $N(m(i) + 1, i) \ge \frac{\delta}{2}(i - m (i)) $.
\begin{itemize}
\item
\end{itemize}
\end{enumerate}
\end{lemma}
\noindent Combining the three lemmas, Braverman and Rao conclude that the protocol above corrects $\frac{\delta}{2}$-fraction errors.
The main idea is that we measure our progress by looking at the longest path length in $S_A \cup S_B$ so far. As we never delete anything, even when a miscommunication is evident, we never get worse during a round. If Alice adds some edge to $S_A$ and Bob does not add a next edge to $S_B$, then it is because of the adversary. But the adversary only has a limited number of errors it can cause, so $S_B$ will eventually contain the next edge, and the protocol will eventually approach the true path.
\section{Parting Shots}
In this lecture we described the mechanism of tree codes as a way to protect against noise in an interaction. We also discussed two examples of protocols---the original by Schulman and another by Braverman and Rao---that utilize these tree codes. However, it is worth noting that none of these are constructive. It also should be said that constructive encoding and decoding of tree codes would imply that the Braverman-Rao protocol is constructive. Currently, there have been no results showing the constructiveness of the protocol, but there are work-around ideas to the protocol that are close. However, in literature there are no deterministic efficient protocols for interactive coding, nor are there explicit constructions of any tree code.
\end{document}