 Hey, for once I'm here without an IATR slide, but with something about crypto. But crypto here means crypto consensus, no blockchain even, but it means consensus. So I'm going to talk about protocols for this reaching agreement, also known as consensus. This was trying to work with Björn Takman of IBM. So in the protocols, in the blockchains, you want to reach an agreement as Erika just nicely introduced, I don't have to go through this. But we want to tolerate uncertainties and foxes and everyone else being delayed or slow or lying. And this is of course older than blockchain protocols, but it's been made much more relevant again by this recent craze. So as cryptographers, you might not know all of this slide by heart because in crypto conferences I see about half of the papers who forget to define aliveness. But everybody here is definitely an expert on safety. So aliveness means also that something good will eventually happen. And unless you satisfy both properties in a distributed protocol, you won't see much action. So about the trust assumptions that we are using. The trust assumptions that we are using normally are defined by the numbers. You see the F-folding nodes, the T-folding nodes and there are n of them and the trust is by the numbers. Why should you think that these nodes are all equal? And assuming that trust by the numbers, it means that all the nodes fail independently of each other. So probability that one further node fails is independent of the first ones. However, this may not be the case in real world systems. And so in those systems, for those systems, already a long while ago people invented the way to specify the trust assumptions through arbitrary sets of possibly faulty nodes. And then you get arbitrary so-called quorums that specify who is correct. But what we are seeing in both of these previous works and these previous models is that everybody uses the same trust assumption. You think the number of faults is this and you also think the number of faults is this and you run the system with maximum resilience. However, this does not have to be the case. And some prominent blockchain systems have explored this. So there is a system called Ripple that uses the idea that you can declare who you vote in the consensus protocol, who you're listening to for your votes in the consensus protocol, because you're declaring a unique list of nodes that you're ever listening to. So like a subjective trust. But there is no description of this protocol apart from the code. So it's inherently difficult to tell whether it actually does consensus or not. And I'm convinced it does not. Because also people have looked at this and tried to figure out what happens. There is a sibling of Ripple that's called Stellar. It evolved originally from Ripple in the code. It's also quite well known. It also aims at achieving this consensus among nodes where each node can declare who they trust. And they aim to achieve this notion of so-called federated Byzantine agreement. But it also doesn't exist. It also does not achieve it in a way where if you project everything to the same trust, symmetric trust assumption will get the existing protocols. So to motivate this, to motivate what I wanted to tell you here is about that we have a notion fixing these problems or addressing these problems in a better way. We go back to Quorum systems where a Quorum system specifies the sets that you are willing to tolerate. And then each participant in the protocol can specify its own Quorum system. And then you get basically an array of such Quorum systems that you're setting next to each other. And the condition that you had in the traditional systems that was just explained before, that you need to be n bigger than 3f, something like this. This translates into a more complicated condition that you see in the middle here that you remove faulty sets that are faulty according to two notions that remains the one correct guy. Now, of course, if we are starting to construct protocols according to such systems, there are going to be nodes who made the wrong assumptions. They trust the wrong friends because not everybody trusts the same nodes in the system. And forgetting this now is properly specified. We can only make such guarantees for the nodes that are wise, namely because they made the correct trust assumption. Not everybody has the same trust assumption. And we do have protocols for various primitives from distributed computing, from Byzantine tolerant protocols, and for consensus in this model. And they satisfied a nice property that there are generalizations of the existing models. And if you want to read more about this, then I have a slide here. And if you talk Latin, then you'll see why this is the case, namely that not everybody wants to have the same trust assumption because trust is inherently subjective, just like taste. Thank you.