 Human beings face big problems. In fact, our biggest problems are so big, we often don't even recognize them as problems. We see them as impossible obstacles that we learn to avoid, not tackle. We need to feed increasing numbers of people, change the way we use natural resources, better manage volatile global economies, and counter-emergent viruses. Before quantum computers can start to solve these grand challenges, we need to solve some grand challenges of our own. In September, we showed a hardware roadmap and a clear vision of how we get to the inflection point of 1,000 qubits over the next three years. But our ultimate objective is not just to create 1,000 qubits in hardware. Our ultimate objective is to make this hardware useful, not just for the relatively small number of quantum experts, but for the vast majority of the 12 million regular professional developers on the planet today. To do this, we need to make the adoption of this radical technology as frictionless as possible. In other words, developers don't have to learn new tools or languages and can even use their existing code. All they need is a few lines of code to call a quantum API service on the cloud. We also have to understand that as part of the most active quantum development community in the world and proudly open source, there are many different kinds of developers working at different levels. Our aim is to help orchestrate this ecosystem so multiple developers can contribute to each layer, each feeding the layer above, providing abstraction without trivialization. So we like to say that frictionless development starts from the bottom up. So going back to our roadmap, here's where we want to be. Simple cloud-based services created by model developers that any developer can use. Now bear in mind it took classical computers 60 years to go from programming with individual logic gates to sophisticated cloud services that developers use today. With quantum computing, we need to go through the same process in the next three years. So this is our plan for how we make this happen. Before we can even think about cloud services, we need to radically improve the performance of quantum hardware. And we do this with a layer of software that interacts with our classical control systems. Currently, our circuit API, which goes back to 2016, allows users to create an object that defines the quantum instructions sent to the quantum computer. This is fine for simple circuits, but to reach our objective, we need to run many more circuits much faster. So our first announcement is we're launching our quantum runtime in 2021. This will support iterative, efficient running of different circuits and updating the future circuits based on measurements of the previous one. We'll be demoing this later in the year where we're aiming to show a significant performance increase. With today's implementation, all these loops run on the user's computer backwards and forwards across the cloud. With the quiz kit runtime, we execute these loops physically close to the quantum computer. This will speed up applications like this example by factors as large as 100 times, making something impractical today possible. Another thing we need to do in order to reach our ultimate destination are what we call dynamic circuits. These are circuits that are smart and can offer branching within the circuit based on measurements within the circuit. We call them dynamic because they can change their future state based on measurements that happen in the middle. And this is why we need a classical hardware to do it. This is a real hurdle. It is very hard to create these, but the good news is we've already made significant strides. We're also announcing we've already made mid-circuit measurements and mid-circuit reset up and running and available for use today. In this figure, we see that by running the reset multiple times, the fidelity at preparing the zero state can get much better. Plus, we've also demonstrated some simple feed forward showing advantages of using iterative phase estimation. Iterative phase estimation is a core sub-algorithm for quantum applications and amounts to solving the following. Imagine the problem of phase estimation of some unitary and here we want to do it with a minimum number of resources. In one case, we could do it all with a dynamic circuit or by post-processing many circuits. Here we see that for the dynamic circuit case, we can win for limited resources. So this is a major first step to dynamic circuits. As we evolve, we predict certain circuits will get used more and more frequently. So we want to offer a library of optimized pre-built ones optimized for the quantum hardware and applications in mind. Once we're dealing with thousands of qubits, we'll need more and more efficient tools to manage these large circuits. We'll need tools to study error correction and the execution of millions of circuits a developer want to run. To do this, we need advanced control electronics built from the ground up to integrate seamlessly with classical HPC. Having HPC tightly bound to quantum resources will allow us to level up our ability to solve for much more complex computation. The next layer of software we envision being developed by algorithm developers. In 2020, we saw our first module being developed out in the open for optimization and natural sciences using the tools that the kernel developers have built. By 2023, it will make sense to create pre-built quantum runtimes in order to run more efficiently followed by pre-built runtimes for classical and quantum resources. These will be deeply tuned to the specific problem set that users and developers want to explore. Then finally to scale these open source modules, we need to integrate them into the cloud. Running on top of these runtimes, this gets us to our ultimate objective. So to recap, here's what it looks like by year. Up until 2019, quantum circuits were run on the IBM cloud. In 2020, we focused on demonstrating and prototyping quantum applications. And in 2021, we'll run quantum applications 100 times faster on the IBM cloud. And in 2022, we'll increase the possibility and algorithms that can be explored with dynamic circuits. In 2023, we'll get to our goal of frictionless development with quantum workflows being built into the cloud. In 2024, with our 1000 qubit systems, we'll build quantum services from the cloud and investigate things such as error correction. And in 2025, we'll enhance quantum workflows through HPC and quantum resources. As I said, at the start of this talk, human beings face seemingly impossible problems. Quantum computers allow us to see with fresh eyes, repositioning the seemingly impossible as grand challenges we can actually tackle and even turn into opportunities. We're on a journey to make this happen and we look forward to doing this with our IBM quantum users, partners and developers. And if developers can eventually do all this with a few simple lines of code using their existing tools, we've succeeded. Thank you.