# [Linkpost] Theory and AI Alignment (Scott Aaronson)


Some excerpts below:

### On Paul's "No-Coincidence Conjecture"

> Related to backdoors, maybe the clearest place where theoretical computer science can contribute to AI alignment is in the study of mechanistic interpretability. If you’re given as input the weights of a deep neural net, what can you learn from those weights in polynomial time, beyond what you could learn from black-box access to the neural net?
> 
> In the worst case, we certainly expect that some information about the neural net’s behavior could be cryptographically obfuscated. And answering certain kinds of questions, like “does there exist an input to this neural net that causes it to output 1?”, is just provably NP-hard.
> 
> That’s why I love a question that [Paul Christiano](https://paulfchristiano.com/), then of the [Alignment Research Center (ARC)](https://www.alignment.org/), raised a couple years ago, and which has become known as the No-Coincidence Conjecture. Given as input the weights of a neural net C, Paul essentially asks how hard it is to distinguish the following two cases:
> 
> *   **NO-case:** C:{0,1}^2n^→R^n^ is totally random (i.e., the weights are i.i.d., N(0,1) Gaussians), or
>     
> *   **YES-case:** C(x) has at least one positive entry for all x∈{0,1}^2n^.
>     
> 
> Paul conjectures that there’s at least an NP witness, proving with (say) 99% confidence that we’re in the YES-case rather than the NO-case. To clarify, there should certainly be an NP witness that we’re in the NO-case rather than the YES-case—namely, an x such that C(x) is all negative, which you should think of here as the “bad” or “kill all humans” outcome. In other words, the problem is in the class [coNP](https://en.wikipedia.org/wiki/Co-NP). Paul thinks it’s also in NP. Someone else might make the even stronger conjecture that it’s in P.
> 
> Personally, I’m skeptical: I think the “default” might be that we satisfy the other unlikely condition of the YES-case, when we do satisfy it, for some totally inscrutable and obfuscated reason. But I like the fact that there *is* an answer to this! And that the answer, whatever it is, would tell us *something* new about the prospects for mechanistic interpretability.

### On the utility of training data for mech-interp

> I can’t resist giving you another example of a theoretical computer science problem that came from AI alignment—in this case, an extremely recent one that I learned from my friend and collaborator [Eric Neyman](https://sites.google.com/view/ericneyman/) at ARC. This one is motivated by the question: when doing mechanistic interpretability, how much would it help to have access to the training data, and indeed the entire training process, in addition to weights of the final trained model? And to whatever extent it does help, is there some short “digest” of the training process that would serve just as well? But we’ll state the question as just abstract complexity theory.

> Suppose you’re given a polynomial-time computable function f:{0,1}^m^→{0,1}^n^, where (say) m=n^2^. We think of x∈{0,1}^m^ as the “training data plus randomness,” and we think of f(x) as the “trained model.” Now, suppose we want to compute lots of properties of the model that *information-theoretically* depend only on f(x), but that might only be *efficiently* computable given x also. We now ask: is there an efficiently-computable O(n)-bit “digest” g(x), such that these same properties are also efficiently computable given only g(x)?
> 
> Here’s a potential counterexample that I came up with, based on the RSA encryption function (so, not a quantum-resistant counterexample!). Let N be a product of two n-bit prime numbers p and q, and let b be a generator of the multiplicative group mod N. Then let f(x) = b^x^ (mod N), where x is an n^2^-bit integer. This is of course efficiently computable because of repeated squaring. And there’s a short “digest” of x that lets you compute, not only b^x^ (mod N), but also c^x^ (mod N) for any other element c of the multiplicative group mod N. This is simply x mod φ(N), where φ(N)=(p-1)(q-1) is the Euler totient function—in other words, the period of f. On the other hand, it’s totally unclear how to compute this digest—or, crucially, *any other O(m)-bit digest that lets you efficiently compute c^x^ (mod N) for any c*—unless you can factor N. There’s much more to say about Eric’s question, but I’ll leave it for another time.

### On debate and complexity theory

> Yet another place where computational complexity theory might be able to contribute to AI alignment is in the field of [AI safety via debate](https://arxiv.org/abs/1805.00899). Indeed, this is the direction that the OpenAI alignment team was most excited about when they recruited me there back in 2022. They wanted to know: could celebrated theorems like [IP=PSPACE](https://en.wikipedia.org/wiki/IP_(complexity)), [MIP=NEXP](https://www.math.toronto.edu/swastik/courses/rutgers/topics-S17/lec9.pdf), or the [PCP Theorem](https://en.wikipedia.org/wiki/PCP_theorem) tell us anything about how a weak but trustworthy “verifier” (say a human, or a primitive AI) could force a powerful but untrustworthy super-AI to tell it the truth? An obvious difficulty here is that theorems like IP=PSPACE all presuppose a mathematical formalization of the statement whose truth you’re trying to verify—but how do you mathematically formalize “this AI will be nice and will do what I want”? Isn’t that, like, 90% of the problem? Despite this difficulty, I still hope we’ll be able to do something exciting here.