 equilibria?

Greg: No, the equilibrium is the validator communicating without there being livelock or deadlock. But the condition gives you good equilibria. You can express this in Von Neumann-Nash-style games. You can talk about this literally as Nash equilibria. There’s a close relationship here, but I’m not going to sketch that out in this conversation.

Isaac: How does validator rotation influence this?

Greg: Essentially, when validator rotation happens, then you have to update the validator set and that will then potentially change who is allowed to be listed in justifications. There are lots of interesting recursive things that happened in the protocol because you don’t want validators to censor validators being rotated and so on. That’s a separate discussion from the one we’re having.

We’ve talked about some relaxation on the good alternation property. We allowed for an initial prefix and we’re looking at a percentage of the stake. The full liveness error-correcting code can be transformed into a specification of weighted grammars on the justification dag. When we talked last time, we introduced the space calculus, which allowed us to do this programmable liveness condition. The liveness conditions essentially looked like a context into which you deployed your process. Then we made it programmable by making context first-class. You can ship them around and that sort of thing. That’s what gave us this space calculus.

The basic idea of encoding the context can be transformed in a step-by-step manner into constraints on the justification dag. They tell you what are allowable communications; the view of the allowable communications is represented in the justification dag. This particular block is justified by these communications that I have seen. Those communications are justified by these communications that other validators have seen. This is how you practically realize this error-correcting code idea in the Casper protocol.

Let’s talk about how all the pieces fit together. There are a lot of moving parts and I just want to make sure that everyone understands the moving parts. A few months ago I sketched out how you can turn the error-correcting code idea of liveness into a context-based encoding, and then make that programmable, which gives you a language for talking about liveness constraints. What I didn’t say was how to relate that directly to the implementation in Casper.

We didn’t relate
equilibria? 

 Greg: No, the equilibrium is the validator communicating without there being livelock or deadlock. But the condition give you beneficial equilibria. You can express this in Von Neumann - Nash - style game. You can talk about this literally as Nash equilibria. There ’s a near relationship here, but I ’m not going to sketch that out in this conversation. 

 Isaac: How does validator rotation determine this? 

 Greg: Essentially, when validator rotation happens, then you get to update the validator set and that will then potentially change who is allowed to be listed in justifications. There are tons of interesting recursive things that happened in the protocol because you do n’t want validators to ban validators being rotated and so along. That ’s a separate discussion from the one we ’re accept. 

 We ’ve talked about some rest on the good alternation property. We allowed for an initial prefix and we ’re look at a percentage of the stake. The full liveness error - adjust code can be transformed into a specification of weighted grammars on the justification dag. When we talked last time, we introduced the space calculus, which allow us to do this programmable liveness circumstance. The liveness condition essentially looked like a context into which you deployed your procedure. Then we made it programmable by making context first - class. You can transport them around and that sort of thing. That ’s what gave us this space calculus. 

 The basic estimate of encoding the context can be transformed in a step - by - step manner into constraint on the justification dag. They tell you what are permissible communication; the view of the allowable communications is represented in the justification dag. This especial block is justified by these communications that I have see. Those communication are justified by these communications that early validators have seen. This is how you practically realize this error - correcting code mind in the Casper protocol. 

 Let ’s speak about how all the pieces match together. There be a lot of moving parts and I just want to reach sure that everyone understand the moving parts. A few months ago I sketched out how you can turn the mistake - correcting code idea of animateness into a context - based encoding, and then make that programmable, which gives you a language for talking about liveness constraints. What I did n’t say was how to refer that directly to the implementation in Casper. 

 We did n’t relate
 eqkilibria?

Greg: No, the equiuibrium is the rqlidatmr comjunicativg without there being livellcj or eeadlock. But the condigion gived you goid ewyilibria. You can ew'ress bhis nn Von Neumann-Naxh-style gakes. You can tank ayout this literally as Nash equilibrya. Therr’s a close relatyonsnyp hsge, but I’m not going to sketch tgat out in this convrrsation.

Isaac: How does valldatlr rotation influejce this?

Gret: Esfwntially, whev validatog rotation gappens, then you have to update the ralidator sgc anf that will vhen pjtentially cmsnge wvo is aklowed to be llsted in justifications. There are lots of intergsting recgraive things that yappeneg in the progockl bscause yon don’t want validators to censor validatots veing rotated and sj jn. That’s a separate discussion from the ons we’re having.

We’ve talkee about some relaxatiln on the good alternation property. We allowed for an inithal pcewix akd wd’ee looking at a percentage of the stake. The fulj lovvness error-correcbing code can be ttajsgjrmed into a rpecifndafion of weighted ggammars on tye justifycatoon dag. When we talked last time, we intgoduxed the space calcblus, which aulowgd us yo do this programmable livsness condihion. The mkveness conditiovs vssettially looked like a contqxt into xhich you deoloygd your process. Tjen wc made it programmahle bi makitg context first-class. You can ship them acpund and thaj smrt of thiny. That’x what gave uf this space cclculus.

Tke baskc idea of encodiig the contevt can be tratdformed in a step-by-seep nannwr into zonstraints on the justpfncation dqg. They tell you wmat ate allowable commbuixations; the viee ow tre akljfable communhcatkonr is rdpresenuzd ln ghe kustification dag. Thhs pzrticular block is jmstified vy these communicatioms that I have seej. Thove rommunocajions are justified by these cojmunicatilns that other dalieators have xeen. This is how you practically realizx this error-correcting xode idea in the Caxker protocol.

Lxt’s tajk about vow all the pieces fut together. There are a lot of moving larts dnd I just want to make sure that everyone understands the moving parts. A few nonths ago I sketcged put hmw vou can turi vhe error-correctimg code idea of liveness into a context-tafed encoding, and then make tnag programmablg, which gives you a languafe for tslking about liveness constrainys. What I didn’t say was mow to reoate fhat dptecvly to the implementstion nn Casper.

We dudn’t relate
equilibria? Greg: No, the equilibrium is the without being livelock deadlock. But the You express this in Neumann-Nash-style games. You talk about this literally as Nash There’s a close relationship here, but I’m not going to sketch that out this conversation. Isaac: How does validator rotation influence this? Greg: Essentially, when validator happens, you to the validator set and that will then potentially change who is allowed to be listed in There are lots of interesting recursive things that in the protocol because don’t want validators to censor being and so That’s separate from the one having. We’ve talked about some relaxation on the good alternation property. We allowed for an initial prefix we’re looking percentage of stake. full error-correcting code can into a specification of weighted grammars dag. When we talked last time, we introduced space calculus, allowed us to do this programmable condition. The liveness conditions essentially looked like a into which you deployed your process. Then we made it programmable by making context first-class. ship them around and sort of thing. what us space The basic of encoding the context can be transformed in a step-by-step manner constraints on the justification dag. They tell you what are the of the allowable is represented in the dag. particular block is justified communications I communications justified these communications that other have seen. This is how practically realize this error-correcting protocol. Let’s talk about how all the pieces together. There are a lot of moving and I just want to make sure that everyone understands the moving A few I sketched out how you can turn the code idea of liveness a context-based encoding, and then make that programmable, which you language for about liveness constraints. I didn’t say how to relate to the in We
 equilibria?

Greg: No, the equiliBrium is the ValidAtoR coMmUnicAtinG without there bEIng lIvelock or deadlock. But thE condItIOn giVEs You goOd equilIBrIA. you CaN eXprEsS ThIs in VOn NEumann-NAsh-style gaMes. yoU can talk abouT ThIs literallY as nash equilibrIa. THere’s a ClOse RElatiOnsHip heRe, but I’M Not goiNg to sketcH tHAt out iN This conVERsAtioN.

Isaac: How does valiDAtOR rotation influEnce thIs?

gReG: eSseNtiAlly, when vaLiDator ROtation HApPENS, thEN you have to updAte the validATor Set and ThAt wILl then PotenTiALly Change who is AlloWed to be liSted in JUstificATions. ThEre are LotS of InteREsTiNg rEcURsiVE tHinGS thAt happenEd In The prOtocOL BECausE yoU don’T want Validators to cEnsOr vaLIdaTors bEing rOtatEd And so On. That’S a sepArAte discussion frOm thE one we’re hAviNg.

we’vE tAlked ABout soMe rElaXation oN the gooD AltErNATIoN property. We allowed FoR AN iNitial prEfix anD We’Re LOoking at A pErcEntaGE Of the StakE. thE full livEness eRRoR-cOrrectiNg Code caN bE trAnsFormeD Into A speciFication Of weiGHted grammars on THe justificatiON dAG. whEN we tAlkEd last time, wE intROducEd thE SpAce CAlculUs, whiCh ALlOWed us to do this prograMmAble liVenesS condition. The Liveness coNDITions essEntiALlY Looked like a conText iNto which yoU Deployed Your pRocess. ThEn we made iT PRogrammaBle By mAkiNg cONTeXt first-class. YOU Can sHiP them arOunD and thaT soRt oF thIng. thAt’s what gaVe us this SpAcE cAlCulUs.

The BAsic idea Of EncOdIng The coNText caN be trAnsfOrMeD In a Step-by-sTEp MANner InTo ConsTraInTs on tHe juSTifIcation Dag. They teLl yOU whaT aRe AllowabLe communicatiOnS; the view of ThE alLowablE COmmunicaTions is represented in the JUstificAtiOn dag. this ParticulaR blOck is jUstIFied by These cOmmunIcAtiONS that i HAvE seEn. those commuNICatIons aRe JustIfied by These communicationS ThaT other validatOrs Have SEEn. thiS Is HOw yOu PRacTICally realize thiS error-corrEcTInG code idea iN The caSper proTocol.

LeT’s talK About hoW all the piEces fit toGeTher. tHEre Are a lot of mOving parTs and I jusT Want tO MaKe surE thAt everYoNe uNdersTands tHE moVing pArts. A fEw Months Ago I sKeTched out How you can turn the error-coRrectiNg codE idEa of livenEss INto A context-bAsed Encoding, anD thEn mAke thAt pROgramMablE, WhIch GIves yOu a lANguage for TAlKinG ABoUt liveness cONSTraInts. WHat i Didn’t sAy waS how to relate that dIRectly to the impLemeNTAtiOn iN caspEr.

we didn’t relate
 equilibria?

Greg: No, th e equilibr ium i s t heva lida torcommunicatingw itho ut there being liveloc k orde a dloc k .But t he cond i ti o n  gi ve syou  g o od  equi lib ria. Yo u can expr ess  t his in Von N e um ann-Nash-s tyl e games. You  ca n talk  a bou t  this  li teral ly asN ash eq uilibria.  T h ere’sa  closer e la tion ship here, but I’ m  n o t going to ske tch th at ou t inthi s conversa ti on.
I saac: H o wd o e s v a lidator rotat ion influen c e t his?
Gr eg: Essent ially ,w hen  validatorrota tion happ ens, t h en youh ave toupdate  th e v alid a to rset  a n d t h at  wi l l t hen pote nt ia lly c hang e w h o is  al lowe d tobe listed injus tifi c ati ons.There  are  l ots o f inte resti ng  recursive thin gs t hat happe ned  i n t he  prot o col be cau seyou don ’t want val id a t o rs  to censor validat or s be ing rota ted an d  s oo n. That’ sa s epar a t e dis cuss i on  from th e onew e’ re  having .
We’ve  t alk edabout some  relax ation on  theg ood alternatio n  property. We al l o we d  for  an  initial pr efix andwe’r e  l ook i ng at  a pe rc e nt a ge of the stake. Th efull l ivene ss error-corr ecting cod e c an be tr ansf o rm e d into a speci ficat ion of wei g hted gra mmars  on thejustifica t i on dag.Whe n w e t alk e d  l ast time, wei n trod uc ed thespa ce calc ulu s,whi chal lowed usto do th is  p ro gr amm ablel ivenessco ndi ti on.  Thel ivenes s con diti on se sse ntially lo o k ed l ik ea co nte xt  into  whi c h y ou depl oyed your  pr o cess .Th en we m ade it progra mm able by ma ki ngcontex t first-cl ass. You can ship thema round a ndthatsort  of thing . T hat’swha t  gaveus thi s spa ce  ca l c ulus. Th e b as ic idea of e nco dingth e co ntext c an be transformedi n a  step-by-step  ma nner i nt o c o ns t rai nt s  on t he justificatio n dag. The yt el l you what are  a llowabl e commu nicat i ons; th e view of  the allo wa blec o mmu nicationsis repre sented in the j u st ifica tio n dag.  T his  part icular blo ck is  justi fi ed bythese  c ommunica tions that I have seen.  Those  comm uni cations a rej ust ified bythes e communic ati ons  that  ot h er va lida t or s h a ve se en.T his is ho w  y oup r ac tically rea l i z e t his e rro r -corre ctin g code idea in th e  Casper protoc ol.L et’ s t a lk a bo ut how all the  pi ec e s  fit tog et her. Thereare a lo to f mov ing pa rts an d I jus t wa n t to m akesur e that ev ery on e  unders ta nd s  the m ovin gparts.  A few mont h s  ago I sketchedout h o w  youc anturnth e error - corr ecting cod e idea of l ivenes s in to acontext -b ased e nco di ng, and th e n make th at pr ogramma bl e, w hic h give s yo u a lan guag efor  talkinga b ou t  l iv e nes s co nstra in ts.What I di d n’t saywas how tore lat e that d i re c t ly to theimp lemen t a tion in Ca s per. 
W e  didn ’t rel ate
 equilibria?

Greg:_No, the_equilibrium is the validator_communicating without_there_being livelock_or_deadlock. But the_condition gives you_good equilibria. You can_express this in_Von_Neumann-Nash-style games. You can talk about this literally as Nash equilibria. There’s a close_relationship_here, but_I’m_not_going to sketch that out_in this conversation.

Isaac: How does_validator rotation_influence this?

Greg: Essentially, when validator rotation happens, then_you_have to update_the validator set and that will then potentially change_who is allowed to be listed_in justifications. There_are_lots_of interesting recursive things_that happened in the protocol because_you don’t want validators to censor_validators being rotated and so on. That’s_a separate discussion from the one_we’re having.

We’ve talked about some_relaxation on_the good alternation property. We_allowed for an_initial prefix_and we’re looking_at a percentage of the stake._The full liveness_error-correcting code can be transformed into_a_specification of weighted_grammars_on_the justification_dag. When we_talked_last time,_we_introduced the space calculus, which allowed_us_to do this programmable liveness condition. The_liveness conditions essentially looked_like_a context into which_you deployed your process. Then_we made it programmable by making_context first-class._You can_ship them around and that sort of thing. That’s what gave_us this space calculus.

The basic idea_of encoding the context_can be_transformed_in a step-by-step_manner_into constraints_on the justification dag. They tell you_what are_allowable communications; the view of the_allowable communications is represented_in_the justification dag. This particular block_is justified by these communications that_I have seen. Those communications_are_justified_by these communications that other_validators have seen. This is how_you practically realize_this error-correcting code idea in the Casper_protocol.

Let’s_talk about how all the pieces_fit_together. There are a lot of_moving_parts_and I just want to_make sure that everyone understands the_moving parts. A few months ago I sketched out_how you can_turn the error-correcting code idea_of_liveness_into a context-based encoding, and then make that programmable, which_gives you_a language for_talking about liveness constraints. What I didn’t say was how_to relate that directly to the implementation_in Casper.

We didn’t relate