# One definition of algorithmic fairness: statistical parity

If you haven’t read the first post on fairness, I suggest you go back and read it because it motivates why we’re talking about fairness for algorithms in the first place. In this post I’ll describe one of the existing mathematical definitions of “fairness,” its origin, and discuss its strengths and shortcomings.

Before jumping in I should remark that nobody has found a definition which is widely agreed as a good definition of fairness in the same way we have for, say, the security of a random number generator. So this post is intended to be exploratory rather than dictating The Facts. Rather, it’s an idea with some good intuitive roots which may or may not stand up to full mathematical scrutiny.

## Statistical parity

Here is one way to define fairness.

Your population is a set $X$ and there is some known subset $S \subset X$ that is a “protected” subset of the population. For discussion we’ll say $X$ is people and $S$ is people who dye their hair teal. We are afraid that banks give fewer loans to the teals because of hair-colorism, despite teal-haired people being just as creditworthy as the general population on average.

Now we assume that there is some distribution $D$ over $X$ which represents the probability that any individual will be drawn for evaluation. In other words, some people will just have no reason to apply for a loan (maybe they’re filthy rich, or don’t like homes, cars, or expensive colleges), and so $D$ takes that into account. Generally we impose no restrictions on $D$, and the definition of fairness will have to work no matter what $D$ is.

Now suppose we have a (possibly randomized) classifier $h:X \to \{-1,1\}$ giving labels to $X$. When given a person $x$ as input $h(x)=1$ if $x$ gets a loan and $-1$ otherwise. The bias, or statistical imparity, of $h$ on $S$ with respect to $X,D$ is the following quantity. In words, it is the difference between the probability that a random individual drawn from $S$ is labeled 1 and the probability that a random individual from the complement $S^C$ is labeled 1.

$\textup{bias}_h(X,S,D) = \Pr[h(x) = 1 | x \in S^{C}] – \Pr[h(x) = 1 | x \in S]$

The probability is taken both over the distribution $D$ and the random choices made by the algorithm. This is the statistical equivalent of the legal doctrine of adverse impact. It measures the difference that the majority and protected classes get a particular outcome. When that difference is small, the classifier is said to have “statistical parity,” i.e. to conform to this notion of fairness.

Definition: A hypothesis $h:X \to \{-1,1\}$ is said to have statistical parity on $D$ with respect to $S$ up to bias $\varepsilon$ if $|\textup{bias}_h(X,S,D)| < \varepsilon$.

So if a hypothesis achieves statistical parity, then it treats the general population statistically similarly to the protected class. So if 30% of normal-hair-colored people get loans, statistical parity requires roughly 30% of teals to also get loans.

It’s pretty simple to write a program to compute the bias. First we’ll write a function that computes the bias of a given set of labels. We’ll determine whether a data point $x \in X$ is in the protected class by specifying a specific value of a specific index. I.e., we’re assuming the feature selection has already happened by this point.

# labelBias: [[float]], [int], int, obj -&gt; float
# compute the signed bias of a set of labels on a given dataset
def labelBias(data, labels, protectedIndex, protectedValue):
protectedClass = [(x,l) for (x,l) in zip(data, labels)
if x[protectedIndex] == protectedValue]
elseClass = [(x,l) for (x,l) in zip(data, labels)
if x[protectedIndex] != protectedValue]

if len(protectedClass) == 0 or len(elseClass) == 0:
raise Exception(&quot;One of the classes is empty!&quot;)
else:
protectedProb = sum(1 for (x,l) in protectedClass if l == 1) / len(protectedClass)
elseProb = sum(1 for (x,l) in elseClass  if l == 1) / len(elseClass)

return elseProb - protectedProb


Then generalizing this to an input hypothesis is a one-liner.

# signedBias: [[float]], int, obj, h -&gt; float
# compute the signed bias of a hypothesis on a given dataset
def signedBias(data, h, protectedIndex, protectedValue):
return labelBias(pts, [h(x) for x in pts], protectedIndex, protectedValue)


Now we can load the census data from the UCI machine learning repository and compute some biases in the labels. The data points in this dataset correspond to demographic features of people from a census survey, and the labels are +1 if the individual’s salary is at least 50k, and -1 otherwise. I wrote some helpers to load the data from a file (which you can see in this post’s Github repo).

if __name__ == &quot;__main__&quot;:

# [(test name, (index, value))]
tests = [('gender', (1,0)),
('private employment', (2,1)),
('asian race', (33,1)),
('divorced', (12, 1))]

for (name, (index, value)) in tests:
print(&quot;'%s' bias in training data: %.4f&quot; %
(name, labelBias(train, train, index, value)))


(I chose ‘asian race’ instead of just ‘asian’ because there are various ‘country of origin’ features that are for countries in Asia.)

Running this gives the following.

anti-'female' bias in training data: 0.1963
anti-'private employment' bias in training data: 0.0731
anti-'asian race' bias in training data: -0.0256
anti-'divorced' bias in training data: 0.1582


Here a positive value means it’s biased against the quoted thing, a negative value means it’s biased in favor of the quoted thing.

Now let me define a stupidly trivial classifier that predicts 1 if the country of origin is India and zero otherwise. If I do this and compute the gender bias of this classifier on the training data I get the following.

&gt;&gt;&gt; indian = lambda x: x == 1
&gt;&gt;&gt; len([x for x in train if indian(x)]) / len(train) # fraction of Indians
0.0030711587481956942
&gt;&gt;&gt; signedBias(train, indian, 1, 0)
0.0030631816119030884


## For work while travelling

My favorite so far is ShareLaTeX. I’ve used a bunch of online TeX editors, most notably Overleaf (formerly WriteLaTeX). They’re both pretty solid, but a few features tip me toward ShareLaTeX. I’ll italicize these things below.

Mindset: An editor I can use on my Chromebook or a public machine, yet still access my big papers and projects in progress. Needs support for figures, bibliographies, the whole shebang. Basically I need a browser replacement for a desktop LaTeX setup. I generally do not need collaboration services, because the de facto standard among everyone I’ve ever interacted with is that you can only expect people to have Dropbox. You cannot expect them to sign up for online services just to work with you.

Use cases:

• Drafting actual research papers
• Writing slides/talks

Awesome features: Dropbox integration! This is crucial, because I (and everyone I know) does their big collaborative projects using Dropbox. ShareLaTeX (unlike Overleaf) has seamless Dropbox integration. The only caveat is that ShareLaTeX only accesses Dropbox files that are in a specially-named folder. This causes me to use a bunch of symbolic links that would be annoying to duplicate if I got a new machine.

Other than that, ShareLaTeX (like Overleaf) has tons of templates, all the usual libraries, great customer support, and great collaborative features for the once in a blue moon that someone else uses ShareLaTeX.

Vim commands. The problem is that they don’t go far enough here. They don’t support vim-style word-wrapping (gq), and they leave out things like backward search (? instead of /) and any : commands you tend to use.

Github integration. Though literally no mathematicians I know use Github for anything related to research, I think that with the right features Github could become the “right” solution to paper management. The way people store and “archive” their work is horrendous, and everyone can agree a waste of time. I have lots of ideas for how Github could improve academics’ lives and the lives of the users of their research, too many to list here without derailing the post. The point is that ShareLaTeX having Github integration is forward thinking and makes ShareLaTeX more attractive.

How it could improve: Better vim command support. It seems like many of these services are viewed by their creators as a complete replacement for offline work, when really (for me) it’s a temporary substitute that needs to operate seamlessly with my other services. So basically the more seamless integration it has with services I use, the better.

Caveats: Integration comes at a premium of $8/month for students, and$15/month for non-students.

## Work at home

This is where we get into the nitty gritty of terminal tools. Because naively writing papers in TeX on a desktop has a lot of lame steps and tricks. There are (multiple types of) bibliography files to manage, you have to run like four commands to compile a document, and the TeX compiler errors are often nonsense.

I used to have a simple script to compile;display;clean for me, but then I came across the latexmk program. What you can do is configure latexmk to automatically recompile when a change is made to a source file, and then you can configure a pdf viewer (like Skim) to update when the pdf changes. So instead of the workflow being “Write. Compile. View. Repeat,” It’s “Compile. View. Write until done.”

Of course lots of random TeX distributions come with crusty GUIs that (with configuration) do what latexmk does. But I love my vim, and you have your favorite editor, too. The key part is that latexmk and Skim don’t care what editor you use.

For reference, here’s how I got it all configured on OS X Mavericks.

1. Install latexmk (move the perl script downloadable from their website to anywhere on your $PATH). 2. Add alias latexmk='latexmk.pl -pvc' to your .profile. The -pvc flag makes latexmk watch for changes. 3. Add the following to a new file called .latexmkrc in your home directory (it says: I only do pdfs and use Skim to preview): $pdf_mode = 1; $postscript_mode = 0;$dvi_mode = 0; $pdf_previewer = "open -a /Applications/Skim.app";$clean_ext = "paux lox pdfsync out";
4. Install Skim.
5. In Skim’s preferences, go to the Sync tab and check the box “Check for file changes.”
6. Run the following from the command line, which prevents Skim from asking (once for each file!) whether you want to auto reload that file:
$defaults write -app Skim SKAutoReloadFileUpdate -boolean true Now the workflow is: browse to your working directory; run latexmk yourfile.tex (this will open Skim); open the tex document in your editor; write. When you save the file, it will automatically recompile and display in Skim. Since it’s OS X, you can scroll through the pdf without switching window focus, so you don’t even have to click back into the terminal window to continue typing. Finally, I have two lines in my .vimrc to auto-save every second that the document is idle (or when the window loses focus) so that I don’t have to type :w every time I want the updates to display. To make this happen only when you open a tex file, add these lines instead to ~/.vim/ftplugin/tex.vim  set updatetime=1000 autocmd CursorHoldI,CursorHold,BufLeave,FocusLost silent! wall  Caveats: I haven’t figured out how to configure latexmk to do anything more complicated than this. Apparently it’s possible to get it setup to work with “Sync support,” which means essentially you can go back and forth between the source file lines and the corresponding rendered document lines by clicking places. I think reverse search (pdf->vim) isn’t possible with regular vim (it is apparently with macvim), but forward search (vim->pdf) is if you’re willing to install some plugins and configure some files. So here is the place where Skim does care what editor you use. I haven’t yet figured out how to do it, but it’s not a feature I care much for. One deficiency I’ve found: there’s no good bibliography manager. Sorry, Mendeley, I really can’t function with you. I’ll just be hand-crafting my own bib files until I find or make a better solution. Have any great tools you use for science and paper writing? I’d love to hear about them. # On the Computational Complexity of MapReduce I recently wrapped up a fun paper with my coauthors Ben Fish, Adam Lelkes, Lev Reyzin, and Gyorgy Turan in which we analyzed the computational complexity of a model of the popular MapReduce framework. Check out the preprint on the arXiv. Update: this paper is now published in the proceedings of DISC2015. As usual I’ll give a less formal discussion of the research here, and because the paper is a bit more technically involved than my previous work I’ll be omitting some of the more pedantic details. Our project started after Ben Moseley gave an excellent talk at UI Chicago. He presented a theoretical model of MapReduce introduced by Howard Karloff et al. in 2010, and discussed his own results on solving graph problems in this model, such as graph connectivity. You can read Karloff’s original paper here, but we’ll outline his model below. Basically, the vast majority of the work on MapReduce has been algorithmic. What I mean by that is researchers have been finding more and cleverer algorithms to solve problems in MapReduce. They have covered a huge amount of work, implementing machine learning algorithms, algorithms for graph problems, and many others. In Moseley’s talk, he posed a question that caught our eye: Is there a constant-round MapReduce algorithm which determines whether a graph is connected? After we describe the model below it’ll be clear what we mean by “solve” and what we mean by “constant-round,” but the conjecture is that this is impossible, particularly for the case of sparse graphs. We know we can solve it in a logarithmic number of rounds, but anything better is open. In any case, we started thinking about this problem and didn’t make much progress. To the best of my knowledge it’s still wide open. But along the way we got into a whole nest of more general questions about the power of MapReduce. Specifically, Karloff proved a theorem relating MapReduce to a very particular class of circuits. What I mean is he proved a theorem that says “anything that can be solved in MapReduce with so many rounds and so much space can be solved by circuits that are yae big and yae complicated, and vice versa.” But this question is so specific! We wanted to know: is MapReduce as powerful as polynomial time, our classical notion of efficiency (does it equal P)? Can it capture all computations requiring logarithmic space (does it contain L)? MapReduce seems to be somewhere in between, but it’s exact relationship to these classes is unknown. And as we’ll see in a moment the theoretical model uses a novel communication model, and processors that never get to see the entire input. So this led us to a host of natural complexity questions: 1. What computations are possible in a model of parallel computation where no processor has enough space to store even one thousandth of the input? 2. What computations are possible in a model of parallel computation where processors can’t request or send specific information from/to other processors? 3. How the hell do you prove that something can’t be done under constraints of this kind? 4. How do you measure the increase of power provided by giving MapReduce additional rounds or additional time? These questions are in the domain of complexity theory, and so it makes sense to try to apply the standard tools of complexity theory to answer them. Our paper does this, laying some brick for future efforts to study MapReduce from a complexity perspective. In particular, one of our theorems is the following: Theorem: Any problem requiring sublogarithmic space$ o(\log n)$can be solved in MapReduce in two rounds. This theorem is nice for two reasons. First is it’s constructive. If you give me a problem and I know it classically takes less than logarithmic space, then this gives an automatic algorithm to implement it in MapReduce, and if you were so inclined you could even automate the process of translating a classical algorithm to a MapReduce algorithm (it’s not pretty, but it’s possible). One example of such a useful problem is string searching: if you give me a fixed regex, I can search a large corpus for matches to that regex in actually constant space, and hence in MapReduce in two rounds. Our other results are a bit more esoteric. We relate the questions about MapReduce to old, deep questions about computations that have simultaneous space and time bounds. In the end we give a (conditional, nonconstructive) answer to question 4 above, which I’ll sketch without getting too deep in the details. It’s interesting despite the conditionalness and nonconstructiveness because it’s the first result of its kind for MapReduce. So let’s start with the model of Karloff et al., which they named “MRC” for MapReduce Class. ## The MRC Model of Karloff et al. MapReduce is a programming paradigm which is intended to make algorithm design for distributed computing easier. Specifically, when you’re writing massively distributed algorithms by hand, you spend a lot of time and effort dealing with really low-level questions. Like, what do I do if a processor craps out in the middle of my computation? Or, what’s the most efficient way to broadcast a message to all the processors, considering the specific topology of my network layout means the message will have to be forwarded? These are questions that have nothing to do with the actual problem you’re trying to solve. So the designers of MapReduce took a step back, analyzed the class of problems they were most often trying to solve (turns out, searching, sorting, and counting), and designed their framework to handle all of the low-level stuff automatically. The catch is that the algorithm designer now has to fit their program into the MapReduce paradigm, which might be hard. In designing a MapReduce algorithm, one has to implement two functions: a mapper and a reducer. The mapper takes a list of key-value pairs, and applies some operation to each element independently (just like the map function in most functional programming languages). The reducer takes a single key and a list of values for that key, and outputs a new list of values with the same key. And then the MapReduce protocol iteratively applies mappers and reducers in rounds to the input data. There are a lot of pictures of this protocol on the internet. Here’s one An interesting part of this protocol is that the reducers never get to communicate with each other, except indirectly through the mappers in the next round. MapReduce handles the implied grouping and message passing, as well as engineering issues like fault-tolerance and load balancing. In this sense, the mappers and reducers are ignorant cogs in the machine, so it’s interesting to see how powerful MapReduce is. The model of Karloff, Suri, and Vassilvitskii is a relatively straightforward translation of this protocol to mathematics. They make a few minor qualifications, though, the most important of which is that they encode a bound on the total space used. In particular, if the input has size$ n$, they impose that there is some$ \varepsilon > 0$for which every reducer uses space$ O(n^{1 – \varepsilon})$. Moreover, the number of reducers in any round is also bounded by$ O(n^{1 – \varepsilon})$. We can formalize all of this with a few easy definitions. Definition: An input to a MapReduce algorithm is a list of key-value pairs$ \langle k_i,v_i \rangle_{i=1}^N$of total size$ n = \sum_{i=1}^N |k_i| + |v_i|$. For binary languages (e.g., you give me a binary string$ x$and you want to know if there are an odd number of 1’s), we encode a string$ x \in \{ 0,1 \}^m$as the list$ \langle x \rangle := \langle i, x_i \rangle_{i=1}^n$. This won’t affect any of our space bounds, because the total blowup from$ m = |x|$to$ n = |\langle x \rangle |$is logarithmic. Definition: A mapper$ \mu$is a Turing machine which accepts as input a single key-value pair$ \langle k, v \rangle$and produces as output a list of key-value pairs$ \langle k_1′, v’_1 \rangle, \dots, \langle k’_s, v’_s \rangle$. Definition: reducer$\rho$is a Turing machine which accepts as input a key$ k$and a list of values$ v_1, \dots, v_m$and produces as output the same key and a new list of values$ v’_1, \dots, v’_M$. Now we can describe the MapReduce protocol, i.e. what a program is and how to run it. I copied this from our paper because the notation is the same so far. All we’ve done here is just describe the MapReduce protocol in mathematics. It’s messier than it is complicated. The last thing we need is the space bounds. Definition: A language$ L$is in$ \textup{MRC}[f(n), g(n)]$if there is a constant$ 0 < c < 1$and a sequence of mappers and reducers$ \mu_1, \rho_1, \mu_2, \rho_2, \dots$such that for all$ x \in \{ 0,1 \}^n$the following is satisfied: 1. Letting$ R = O(f(n))$and$ M = (\mu_1, \rho_1, \dots, \mu_R, \rho_R)$,$ M$accepts$ x$if and only if$ x \in L$. 2. For all$ 1 \leq r \leq R$,$ \mu_r, \rho_r$use$ O(n^c)$space and$ O(g(n))$time. 3. Each$ \mu_r$outputs$ O(n^c)$keys in round$ r$. To be clear, the first argument to$ \textup{MRC}[f(n), g(n)]$is the round bound, and the second argument is the time bound. The last point implies the bound on the number of processors. Since we are often interested in a logarithmic number of rounds, we can define$ \displaystyle \textup{MRC}^i = \textup{MRC}[\log^i(n), \textup{poly}(n)]$So we can restate the question from the beginning of the post as, Is graph connectivity in$ \textup{MRC}^0$? Here there’s a bit of an issue with representation. You have to show that if you’re just given a binary string representing a graph, that you can translate that into a reasonable key-value description of a graph in a constant number of rounds. This is possible, and gives evidence that the key-value representation is without loss of generality for all intents and purposes. ## A Pedantic Aside If our goal is to compare MRC with classes like polynomial time (P) and logarithmic space (L), then the definition above has a problem. Specifically the definition above allows one to have an infinite list of reducers, where each one is potentially different, and the actual machine that is used depends on the input size. In formal terminology, MRC as defined above is a nonuniform model of computation. Indeed, we give a simple proof that this is a problem by showing any unary language is in$ \textup{MRC}^1$(which is where many of the MRC algorithms in recent years have been). For those who don’t know, this is a problem because you can encode versions of the Halting problem as a unary language, and the Halting problem is undecidable. We don’t want our model to be able to solve undecidable problems! While this level of pedantry might induce some eye-rolling, it is necessary in order to make statements like “MRC is contained in P.” It’s simply not true for the nonuniform model above. To fix this problem we refined the MRC model to a uniform version. The details are not trivial, but also not that interesting. Check out the paper if you want to know exactly how we do it. It doesn’t have that much of an effect on the resulting analysis. The only important detail is that now we’re representing the entire MRC machine as a single Turing machine. So now, unlike before, any MRC machine can be written down as a finite string, and there are infinitely many strings representing a specific MRC machine. We call our model MRC, and Karloff’s model nonuniform MRC. You can also make randomized versions of MRC, but we’ll stick to the deterministic version here. ## Sublogarithmic Space Now we can sketch the proof that sublogarithmic space is in$ \textup{MRC}^0$. In fact, the proof is simpler for regular languages (equivalent to constant space algorithms) being in$ \textup{MRC}^0$. The idea is as follows: A regular language is one that can be decided by a DFA, say$ G$(a graph representing state transitions as you read a stream of bits). And the DFA is independent of the input size, so every mapper and reducer can have it encoded into them. Now what we’ll do is split the input string up in contiguous chunks of size$ O(\sqrt{n})$among the processors (mappers can do this just fine). Now comes the trick. We have each reducer compute, for each possible state$ s$in$ G$, what the ending state would be if the DFA had started in state$ s$after processing their chunk of the input. So the output of reducer$ j$would be an encoding of a table of the form:$ \displaystyle s_1 \to T_j(s_1) \\ s_2 \to T_j(s_2) \\ \vdots \\ s_{|S|} \to T_j(s_{|S|})$And the result would be a lookup table of intermediate computation results. So each reducer outputs their part of the table (which has constant size). Since there are only$ O(\sqrt{n})$reducers, all of the table pieces can fit on a single reducer in the second round, and this reducer can just chain the functions together from the starting state and output the answer. The proof for sublogarithmic space has the same structure, but is a bit more complicated because one has to account for the tape of a Turing machine which has size$ o(\log n)$. In this case, you split up the tape of the Turing machine among the processors as well. And then you have to keep track of a lot more information. In particular, each entry of your function has to look like “if my current state is A and my tape contents are B and the tape head starts on side C of my chunk of the input” then “the next time the tape head would leave my chunk, it will do so on side C’ and my state will be A’ and my tape contents will be B’.” As complicated as it sounds, the size of one of these tables for one reducer is still less than$ n^c$for some$ c < 1/2$. And so we can do the same trick of chaining the functions together to get the final answer. Note that this time the chaining will be adaptive, because whether the tape head leaves the left or right side will determine which part of the table you look at next. And moreover, we know the chaining process will stop in polynomial time because we can always pick a Turing machine to begin with that will halt in polynomial time (i.e., we know that L is contained in P). The size calculations are also just large enough to stop us from doing the same trick with logarithmic space. So that gives the obvious question: is$ \textup{L} \subset \textup{MRC}^0$? The second part of our paper shows that even weaker containments are probably very hard to prove, and they relate questions about MRC to the problem of L vs P. ## Hierarchy Theorems This part of the paper is where we go much deeper into complexity theory than I imagine most of my readers are comfortable with. Our main theorem looks like this: Theorem: Assume some conjecture is true. Then for every$ a, b > 0$, there is are bigger$ c > a, d > b$such that the following hold:$ \displaystyle \textup{MRC}[n^a, n^b] \subsetneq \textup{MRC}[n^c, n^b], \displaystyle \textup{MRC}[n^a, n^b] \subsetneq \textup{MRC}[n^a, n^d].$This is a kind of hierarchy theorem that one often likes to prove in complexity theory. It says that if you give MRC enough extra rounds or time, then you’ll get strictly more computational power. The conjecture we depend on is called the exponential time hypothesis (ETH), and it says that the 3-SAT problem can’t be solved in$ 2^{cn}$time for any$ 0 < c < 1$. Actually, our theorem depends on a weaker conjecture (implied by ETH), but it’s easier to understand our theorems in the context of the ETH. Because 3-SAT is this interesting problem: we believe it’s time-intensive, and yet it’s space efficient because we can solve it in linear space given$ 2^n$time. This time/space tradeoff is one of the oldest questions in all of computer science, but we still don’t have a lot of answers. For instance, define$ \textup{TISP}(f(n), g(n))$to the the class of languages that can be decided by Turing machines that have simultaneous bounds of$ O(f(n))$time and$ O(g(n))$space. For example, we just said that$ \textup{3-SAT} \in \textup{TISP}(2^n, n)$, and there is a famous theorem that says that SAT is not in$ \textup{TISP}(n^{1.1} n^{0.1})$; apparently this is the best we know. So clearly there are some very basic unsolved problems about TISP. An important one that we address in our paper is whether there are hierarchies in TISP for a fixed amount of space. This is the key ingredient in proving our hierarchy theorem for MRC. In particular here is an open problem: Conjecture: For every two integers$ 0 < a < b$, the classes$ \textup{TISP}(n^a, n)$and$ \textup{TISP}(n^b, n)$are different. We know this is true of time and space separately, i.e., that$ \textup{TIME}(n^a) \subsetneq \textup{TIME}(n^b)$and$ \textup{SPACE}(n^a) \subsetneq \textup{SPACE}(n^b)$. but for TISP we only know that you get more power if you increase both parameters. So we prove a theorem that address this, but falls short in two respects: it depends on a conjecture like ETH, and it’s not for every$ a, b$. Theorem: Suppose ETH holds, then for every$ a > 0$there is a$ b > a$for which$ \textup{TIME}(n^a) \not \subset \textup{TISP}(n^b, n)$. In words, this suggests that there are problems that need both$ n^2$time and$ n^2$space, but can be solved with linear space if you allow enough extra time. Since$ \textup{TISP}(n^a, n) \subset \textup{TIME}(n^a)$, this gives us the hierarchy we wanted. To prove this we take 3-SAT and give it exponential padding so that it becomes easy enough to do in polynomial TISP (and it still takes linear space, in fact sublinear), but not so easy that you can do it in$ n^a$time. It takes some more work to get from this TISP hierarchy to our MRC hierarchy, but the details are a bit much for this blog. One thing I’d like to point out is that we prove that statements that are just about MRC have implications beyond MapReduce. In particular, the last corollary of our paper is the following. Corollary: If$ \textup{MRC}[\textup{poly}(n), 1] \subsetneq \textup{MRC}[\textup{poly}(n), \textup{poly}(n)]$, then L is different from P. In other words, if you’re afforded a polynomial number of rounds in MRC, then showing that constant time per round is weaker than polynomial time is equivalently hard to separating L from P. The theorem is true because, as it turns out,$ \textup{L} \subset \textup{MRC}[textup{poly}(n), 1]$, by simulating one step of a TM across polynomially many rounds. The proof is actually not that complicated (and doesn’t depend on ETH at all), and it’s a nice demonstration that studying MRC can have implications beyond parallel computing. The other side of the coin is also interesting. Our first theorem implies the natural question of whether$ \textup{L} \subset \textup{MRC}^0$. We’d like to say that this would imply the separation of L from P, but we don’t quite get that. In particular, we know that$ \displaystyle \textup{MRC}[1, n] \subsetneq \textup{MRC}[n, n] \subset \textup{MRC}[1, n^2] \subsetneq \textup{MRC}[n^2, n^2] \subset \dots$But at the same time we could live in a world where$ \displaystyle \textup{MRC}[1, \textup{poly}(n)] = \textup{MRC}[\textup{poly}(n), \textup{poly}(n)]$It seems highly unlikely, but to the best of our knowledge none of our techniques prove this is not the case. If we could rule this out, then we could say that$ \textup{L} \subset \textup{MRC}^0$implies the separation of L and P. And note this would not depend on any conjectures. ## Open Problems Our paper has a list of open problems at the end. My favorite is essentially: how do we prove better lower bounds in MRC? In particular, it would be great if we could show that some problems need a lot of rounds simply because the communication model is too restrictive, and nobody has true random access to the entire input. For example, this is why we think graph connectivity needs a logarithmic number of rounds. But as of now nobody really knows how to prove it, and it seems like we’ll need some new and novel techniques in order to do it. I only have the wisps of ideas in that regard, and it will be fun to see which ones pan out. Until next time! # An Update on “Coloring Resilient Graphs” A while back I announced a preprint of a paper on coloring graphs with certain resilience properties. I’m pleased to announce that it’s been accepted to the Mathematical Foundations of Computer Science 2014, which is being held in Budapest this year. Since we first published the preprint we’ve actually proved some additional results about resilience, and so I’ll expand some of the details here. I think it makes for a nicer overall picture, and in my opinion it gives a little more justification that resilient coloring is interesting, at least in contrast to other resilience problems. ## Resilient SAT Recall that a “resilient” yes-instance of a combinatorial problem is one which remains a yes-instance when you add or remove some constraints. The way we formalized this for SAT was by fixing variables to arbitrary values. Then the question is how resilient does an instance need to be in order to actually find a certificate for it? In more detail, Definition:$ r$-resilient$ k$-SAT formulas are satisfiable formulas in$ k$-CNF form (conjunctions of clauses, where each clause is a disjunction of three literals) such that for all choices of$ r$variables, every way to fix those variables yields a satisfiable formula. For example, the following 3-CNF formula is 1-resilient:$ \displaystyle (a \vee b \vee c) \wedge (a \vee \overline{b} \vee \overline{c}) \wedge (\overline{a} \vee \overline{b} \vee c)$The idea is that resilience may impose enough structure on a SAT formula that it becomes easy to tell if it’s satisfiable at all. Unfortunately for SAT (though this is definitely not the case for coloring), there are only two possibilities. Either the instances are so resilient that they never existed in the first place (they’re vacuously trivial), or the instances are NP-hard. The first case is easy: there are no$ k$-resilient$ k$-SAT formulas. Indeed, if you’re allowed to fix$ k$variables to arbitrary values, then you can just pick a clause and set all its variables to false. So no formula can ever remain satisfiable under that condition. The second case is when the resilience is strictly less than the clause size, i.e.$ r$-resilient$ k$-SAT for$ 0 \leq r < k$. In this case the problem of finding a satisfying assignment is NP-hard. We’ll show this via a sequence of reductions which start at 3-SAT, and they’ll involve two steps: increasing the clause size and resilience, and decreasing the clause size and resilience. The trick is in balancing which parts are increased and decreased. I call the first step the “blowing up” lemma, and the second part the “shrinking down” lemma. ## Blowing Up and Shrinking Down Here’s the intuition behind the blowing up lemma. If you give me a regular (unresilient) 3-SAT formula$ \varphi$, what I can do is make a copy of$ \varphi$with a new set of variables and OR the two things together. Call this$ \varphi^1 \vee \varphi^2$. This is clearly logically equivalent to the original formula; if you give me a satisfying assignment for the ORed thing, I can just see which of the two clauses are satisfied and use that sub-assignment for$ \varphi$, and conversely if you can satisfy$ \varphi$it doesn’t matter what truth values you choose for the new set of variables. And further you can transform the ORed formula into a 6-SAT formula in polynomial time. Just apply deMorgan’s rules for distributing OR across AND. Now the choice of a new set of variables allows us to give some resilient. If you fix one variable to the value of your choice, I can always just work with the other set of variables. Your manipulation doesn’t change the satisfiability of the ORed formula, because I’ve added all of this redundancy. So we took a 3-SAT formula and turned it into a 1-resilient 6-SAT formula. The idea generalizes to the blowing up lemma, which says that you can measure the effects of a blowup no matter what you start with. More formally, if$ s$is the number of copies of variables you make,$ k$is the clause size of the starting formula$ \varphi$, and$ r$is the resilience of$ \varphi$, then blowing up gives you an$ [(r+1)s – 1]$-resilient$ (sk)$-SAT formula. The argument is almost identical to the example above the resilience is more general. Specifically, if you fix fewer than$ (r+1)s$variables, then the pigeonhole principle guarantees that one of the$ s$copies of variables has at most$ r$fixed values, and we can just work with that set of variables (i.e., this small part of the big ORed formula is satisfiable if$ \varphi$was$ r$-resilient). The shrinking down lemma is another trick that is similar to the reduction from$ k$-SAT to 3-SAT. There you take a clause like$ v \vee w \vee x \vee y \vee z$and add new variables$ z_i$to break up the clause in to clauses of size 3 as follows:$ \displaystyle (v \vee w \vee z_1) \wedge (\neg z_1 \vee x \vee z_2) \wedge (\neg z_2 \vee y \vee z)$These are equivalent because your choice of truth values for the$ z_i$tell me which of these sub-clauses to look for a true literal of the old variables. I.e. if you choose$ z_1 = T, z_2 = F$then you have to pick either$ y$or$ z$to be true. And it’s clear that if you’re willing to double the number of variables (a linear blowup) you can always get a$ k$-clause down to an AND of 3-clauses. So the shrinking down reduction does the same thing, except we only split clauses in half. For a clause$ C$, call$ C[:k/2]$the first half of a clause and$ C[k/2:]$the second half (you can see how my Python training corrupts my notation preference). Then to shrink a clause$ C_i$down from size$ k$to size$ \lceil k/2 \rceil + 1$(1 for the new variable), add a variable$ z_i$and break$ C_i$into$ \displaystyle (C_i[:k/2] \vee z_i) \wedge (\neg z_i \vee C[k/2:])$and just AND these together for all clauses. Call the original formula$ \varphi$and the transformed one$ \psi$. The formulas are logically equivalent for the same reason that the$ k$-to-3-SAT reduction works, and it’s already in the right CNF form. So resilience is all we have to measure. The claim is that the resilience is$ q = \min(r, \lfloor k/2 \rfloor)$, where$ r$is the resilience of$ \varphi$. The reason for this is that if all the fixed variables are old variables (not$ z_i$), then nothing changes and the resilience of the original$ \phi$keeps us safe. And each$ z_i$we fix has no effect except to force us to satisfy a variable in one of the two halves. So there is this implication that if you fix a$ z_i$you have to also fix a regular variable. Because we can’t guarantee anything if we fix more than$ r$regular variables, we’d have to stop before fixing$ r$of the$ z_i$. And because these new clauses have size$ k/2 + 1$, we can’t do this more than$ k/2$times or else we risk ruining an entire clause. So this give the definition of$ q$. So this proves the shrinking down lemma. ## Resilient SAT is always hard The blowing up and shrinking down lemmas can be used to show that$ r$-resilient$ k$-SAT is NP-hard for all$ r < k$. What we do is reduce from 3-SAT to an$ r$-resilient$ k$-SAT instance in such a way that the 3-SAT formula is satisfiable if and only if the transformed formula is resiliently satisfiable. What makes these two lemmas work together is that shrinking down shrinks the clause size just barely less than the resilience, and blowing up increases resilience just barely more than it increases clause size. So we can combine these together to climb from 3-SAT up to some high resilience and satisfiability, and then iteratively shrink down until we hit our target. One might worry that it will take an exponential number of reductions (or a few reductions of exponential size) to get from 3-SAT to the$ (r,k)$of our choice, but we have a construction that does it in at most four steps, with only a linear initial blowup from 3-SAT to$ r$-resilient$ 3(r+1)$-SAT. Then, to deal with the odd ceilings and floors in the shrinking down lemma, you have to find a suitable larger$ k$to reduce to (by padding with useless variables, which cannot make the problem easier). And you choose this$ k$so that you only need at most two applications of shrinking down to get to$ (k-1)$-resilient$ k$-SAT. Our preprint has the gory details (which has an inelegant part that is not worth writing here), but in the end you show that$ (k-1)$-resilient$ k$-SAT is hard, and since that’s the maximal amount of resilience before the problem becomes vacuously trivial, all smaller resilience values are also hard. ## So how does this relate to coloring? I’m happy about this result not just because it answers an open question I’m honestly curious about, but also because it shows that resilient coloring is more interesting. Basically this proves that satisfiability is so hard that no amount of resilience can make it easier in the worst case. But coloring has a gradient of difficulty. Once you get to order$ k^2$resilience for$ k\$-colorable graphs, the coloring problem can be solved efficiently by a greedy algorithm (and it’s not a vacuously empty class of graphs). Another thing on the side is that we use the hardness of resilient SAT to get the hardness results we have for coloring.

If you really want to stretch the implications, you might argue that this says something like “coloring is somewhat easier than SAT,” because we found a quantifiable axis along which SAT remains difficult while coloring crumbles. The caveat is that fixing colors of vertices is not exactly comparable to fixing values of truth assignments (since we are fixing lots of instances by fixing a variable), but at least it’s something concrete.

Coloring is still mostly open, and recently I’ve been going to talks where people are discussing startlingly similar ideas for things like Hamiltonian cycles. So that makes me happy.

Until next time!