 This is a brief video abstract for the crypto 2022 paper, Succinct Classical Verification of Quantum Computation. This is joint work with James Bartusek, Ya'el Calay, Fermi Ma, Giulio Malavolta, Vinod Vaikunthenathan, Tomaviric, and Lisa Yang. The setting for this work is that of verifiable computation. In this setting, we have some computation represented by deciding membership of a string X in some language L, and this computation is delegated from some verifier to a prover. So the prover and verifier exchange messages in an interactive protocol, and at the end of the protocol, the verifier is supposed to decide whether or not X is in L. And the goal for such a proof system is to have verification be simpler or easier in some sense than deciding whether or not X is in L on your own. So in the classical setting, we have such argument systems, and they're called succinct arguments for NP. And what's known is that for any NP language L, say an n time T, there is an interactive argument system for deciding L where the communication in the protocol is polylog T, so very short, and the verification time is polylog T and some fixed polynomial in the input length. In our setting, we are studying classical verification of quantum computation. And so the primary goal in this setting is to make sure that even though the computation itself requires running a quantum computer, the verifier in such an argument system should still be classical. So the communication should be classical and the verification algorithm should be classical. So with this consideration alone, the breakthrough through work of Mahadev in 2018 showed that assuming the hardness of the learning with errors problem, there are interactive argument systems for every efficient quantum computation where the verifier is classical. So in this work, we managed to construct verifiable computation with both of the efficiency guarantees that we just described. So it is both the case that the verifier is classical even though it is verifying a quantum computation. And moreover, the communication in the protocol is short and the verification is extremely fast. So our formal result is that assuming the hardness of LWE and additionally assuming the existence of indistinguishability obfuscation, we construct succinct arguments for all BQP or even QMA languages where the communication is polylog T where T is the QMA verification time and the verification time of the protocol is polylog T and a fixed polynomial in the instance length. Here are a few highlights of what we do in this work. The succinct argument system is constructed in two parts. The main contribution of this paper is to build a protocol which has a laconic verifier meaning that the verifier to prove a communication is short. This protocol was built assuming IO and LWE. The reason that IO is used is that IO allows us to build a tool that we call a succinct key sampler which gives us a way to have a compressed representation of a large number of essentially independent public keys that we define formally in the paper. This IO based tool is then plugged into a generic template for building classically verifiable quantum computation and then we give a new security proof of this generic type of protocol that is modular and generalizable. In particular, it applies to the protocol with succinct public keys which is what we use in our main result. Then given this laconic verifier protocol we also write down a generic compiler that converts it into a fully succinct argument system and this uses as its main tool a post-quantum succinct argument for classical computation that is sufficiently composable. Then finally, we also write down some extensions of our results that allow us to achieve zero knowledge and also build protocols that are non-interactive given a post-quantum random oracle. This concludes our video abstract. Thanks for listening.