At Levro, our mission is to build the financial backbone for global commerce

Levro

LeBron James and the LeBron James Family Foundation Announce Partnership with Crypto.com LeBron James and the LeBron James Family Foundation (LJFF) has with , the world’s fastest-growing cryptocurrency platform to offer educational and workforce development initiatives focusing on Web3. The partnership will provide kids and families linked to the ‘I PROMISE’ programme with the tools and educational resources they need to engage in and succeed in developing Web3, the internet’s future, on a solid foundation of educational empowerment. partnered Crypto.com Web3 pledges to offer a more just and equitable internet that belongs to the creators, builders, and users. That promise can only be achieved with the active participation of a wide range of people. I PROMISE that children and families will gain a solid foundation in Web3 and the ideas underpinning blockchain-based decentralized apps that fuel the future of many industries, from banking to media to art, resulting from our relationship. James continues to build his community from the bottom up and establish a model for aiding the disadvantaged by delivering Web 3 educational materials and employment development through his Foundation. has been aggressively promoting its name to the globe, paying over $700 million to be the headline sponsor of what was originally the Staples Center for the next 20 years, where James and the Los Angeles Lakers play their home games. Crypto.com The organization has also enlisted Matt Damon to be the face of its platform, with the campaign costing more than $100 million. Many sports stars, such as Steph Curry and Tom Brady, have entered into sponsorship deals with crypto firms, but the partnership is believed to be James’ first major deal with a crypto company. Share the story and don’t forget to like the story!

Crypto.com partners with LeBron James and LeBron James Family Foundation to Bring Web 3 Education

Crypto.com se asocia con LeBron James y LeBron James Family Foundation para llevar la educación Web 3

This paper is available on arxiv under CC BY-NC-SA 4.0 DEED license. Authors: (1) Pascal Baumann, Max Planck Institute for Software Systems (MPI-SWS), Germany; (2) Rupak Majumdar, Max Planck Institute for Software Systems (MPI-SWS), Germany; (3) Ramanathan S. Thinniyam, Max Planck Institute for Software Systems (MPI-SWS), Germany; (4) Georg Zetzsche, Max Planck Institute for Software Systems (MPI-SWS), Germany. Table of Links Introduction Dynamic Networks of Concurret Pushdown Systems (DCPS) Warm-up: Non-Termination Fair Non-Termination From Progressive Runs for VASSB to Reachability Starvation Conclusion, Acknowledgment & References A. Strengthening Fairness to Progressive Runs B. Proofs from Section 4.1 C. Proofs for Section 5 D. Proofs for Section 5.3 E. Proofs for Section 6 7 CONCLUSION ACKNOWLEDGMENTS This research was sponsored in part by the Deutsche Forschungsgemeinschaft project 389792660 TRR 248–CPEC and by the European Research Council under the Grant Agreement 610150 (http://www.impact-erc.eu/) (ERC Synergy Grant ImPACT). REFERENCES Parosh Aziz Abdulla, Karlis Čer ¯ ans, Bengt Jonsson, and Yih-Kuen Tsay. 1996. General decidability theo ¯ rems for infinitestate systems. In Proceedings of the Eleventh Annual Symposium on Logic in Computer Science. IEEE Computer Society Press, 313–321. Krzysztof R. Apt and Ernst-Rüdiger Olderog. 1991. Verification of Sequential and Concurrent Programs. Springer-Verlag. Mohamed Faouzi Atig, Ahmed Bouajjani, Michael Emmi, and Akash Lal. 2012a. Detecting Fair Non-termination in Multithreaded Programs. In Proceedings of CAV 2012. 210–226. https://doi.org/10.1007/978-3-642-31424-7_19 Mohamed Faouzi Atig, Ahmed Bouajjani, K. Narayan Kumar, and Prakash Saivasan. 2012b. Linear-Time Model-Checking for Multithreaded Programs under Scope-Bounding. In Automated Technology for Verification and Analysis - 10th International Symposium, ATVA 2012, Thiruvananthapuram, India, October 3-6, 2012. Proceedings (Lecture Notes in Computer Science), Vol. 7561. Springer, 152–166. Mohamed Faouzi Atig, Ahmed Bouajjani, K. Narayan Kumar, and Prakash Saivasan. 2017. Parity Games on Bounded Phase Multi-pushdown Systems. In Networked Systems - 5th International Conference, NETYS 2017, Marrakech, Morocco, May 17-19, 2017, Proceedings (Lecture Notes in Computer Science), Vol. 10299. Springer, 272–287. Mohamed Faouzi Atig, Ahmed Bouajjani, and Shaz Qadeer. 2009. Context-Bounded Analysis for Concurrent Programs with Dynamic Creation of Threads. In Proceedings of TACAS 2009. 107–123. Mohamed Faouzi Atig, Ahmed Bouajjani, and Shaz Qadeer. 2011. Context-Bounded Analysis For Concurrent Programs With Dynamic Creation of Threads. Log. Methods Comput. Sci. 7, 4 (2011). https://doi.org/10.2168/LMCS-7(4:4)2011 Georg Bachmeier, Michael Luttenberger, and Maximilian Schlund. 2015. Finite Automata for the Sub- and Superword Closure of CFLs: Descriptional and Computational Complexity. In 9th International Conference on Language and Automata Theory and Applications, LATA 2015, Nice, France, March 2-6, 2015, Proceedings. Springer, 473–485. Pascal Baumann, Rupak Majumdar, Ramanathan S. Thinniyam, and Georg Zetzsche. 2020. The Complexity of Bounded Context Switching with Dynamic Thread Creation. In 47th International Colloquium on Automata, Languages, and Programming, ICALP 2020, July 8-11, 2020, Saarbrücken, Germany (Virtual Conference) (LIPIcs), Vol. 168. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 111:1–111:16. Julius Richard Büchi. 1964. Regular canonical systems. Archiv für mathematische Logik und Grundlagenforschung 6, 3-4 (1964), 91–111. Heino Carstensen. 1987. Decidability questions for fairness in Petri nets. In Proceedings of STACS 1987. Springer, 396–407. Byron Cook, Andreas Podelski, and Andrey Rybalchenko. 2007. Proving thread termination. In Proceedings of the ACM SIGPLAN 2007 Conference on Programming Language Design and Implementation, San Diego, California, USA, June 10-13, 2007. ACM, 320–330. Byron Cook, Andreas Podelski, and Andrey Rybalchenko. 2011. Proving program termination. Commun. ACM 54, 5 (2011), 88–98. https://doi.org/10.1145/1941487.1941509 Bruno Courcelle. 1991. On construction obstruction sets of words. EATCS 44 (1991), 178–185. Wojciech Czerwinski, Slawomir Lasota, Ranko Lazic, Jérôme Leroux, and Filip Mazowiecki. 2019. The reachability problem for Petri nets is not elementary. In Proceedings of STOC 2019. 24–33. Antoine Durand-Gasselin, Javier Esparza, Pierre Ganty, and Rupak Majumdar. 2017. Model checking parameterized asynchronous shared-memory systems. Formal Methods Syst. Des. 50, 2-3 (2017), 140–167. https://doi.org/10.1007/s10703-016-0258-3 Paul Erdős and Richard Rado. 1952. Combinatorial Theorems on Classifications of Subsets of a Given Set. Proceedings of the London Mathematical Society s3-2, 1 (01 1952), 417–439. https://doi.org/10.1112/plms/s3-2.1.417 Azadeh Farzan, Zachary Kincaid, and Andreas Podelski. 2016. Proving Liveness of Parameterized Programs. In Proceedings of the 31st Annual ACM/IEEE Symposium on Logic in Computer Science, LICS ’16, New York, NY, USA, July 5-8, 2016. ACM, 185–196. Alain Finkel and Philippe Schnoebelen. 2001. Well-structured transition systems everywhere! Theor. Comput. Sci. 256, 1-2 (2001), 63–92. Marie Fortin, Anca Muscholl, and Igor Walukiewicz. 2017. Model-Checking Linear-Time Properties of Parametrized Asynchronous Shared-Memory Pushdown Systems. In Computer Aided Verification - 29th International Conference, CAV 2017, Heidelberg, Germany, July 24-28, 2017, Proceedings, Part II (Lecture Notes in Computer Science), Vol. 10427. Springer, 155– 175. Pierre Ganty and Rupak Majumdar. 2012. Algorithmic verification of asynchronous programs. ACM Transactions on Programming Languages and Systems (TOPLAS) 34, 1 (2012), 6. Leonard H Haines. 1969. On free monoids partially ordered by embedding. Journal of Combinatorial Theory 6, 1 (1969), 94–98. David Harel. 1986. Effective transformations on infinite trees, with applications to high undecidability, dominoes, and fairness. J. ACM 33 (1986), 224–248. Rodney R Howell, Louis E Rosier, and Hsu-Chun Yen. 1991. A taxonomy of fairness and temporal logic problems for Petri nets. Theoretical Computer Science 82, 2 (1991), 341–372. Petr Jančar. 1990. Decidability of a temporal logic problem for Petri nets. Theoretical Computer Science 74, 1 (1990), 71–93. Vineet Kahlon. 2008. Parameterization as Abstraction: A Tractable Approach to the Dataflow Analysis of Concurrent Programs. IEEE Computer Society, 181–192. Sambasiva Rao Kosaraju. 1982. Decidability of Reachability in Vector Addition Systems (Preliminary Version). In STOC ’82: Proc. of 14th ACM symp. on Theory of Computing. ACM, 267–281. Bernhard Kragl, Constantin Enea, Thomas A. Henzinger, Suha Orhun Mutluergil, and Shaz Qadeer. 2020. Inductive sequentialization of asynchronous programs. In Proceedings of the 41st ACM SIGPLAN International Conference on Programming Language Design and Implementation, PLDI 2020, London, UK, June 15-20, 2020. ACM, 227–242. Akash Lal and Thomas W. Reps. 2009. Reducing concurrent analysis under a context bound to sequential analysis. Formal Methods in System Design 35, 1 (2009), 73–97. https://doi.org/10.1007/s10703-009-0078-9 Akash Lal, Tayssir Touili, Nicholas Kidd, and Thomas W. Reps. 2008. Interprocedural Analysis of Concurrent Programs Under a Context Bound. In Tools and Algorithms for the Construction and Analysis of Systems, 14th International Conference, TACAS 2008, Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2008, Budapest, Hungary, March 29-April 6, 2008. Proceedings (Lecture Notes in Computer Science), Vol. 4963. Springer, 282–298. Jérôme Leroux, Grégoire Sutre, and Patrick Totzke. 2015. On the coverability problem for pushdown vector addition systems in one dimension. In ICALP 2015, Vol. 9135. 324–336. https://doi.org/10.1007/978-3-662-47666-6_26 Irina A. Lomazova and Philippe Schnoebelen. 1999. Some Decidability Results for Nested Petri Nets. In Perspectives of System Informatics, Third International Andrei Ershov Memorial Conference, PSI’99, Akademgorodok, Novosibirsk, Russia, July 6-9, 1999, Proceedings (Lecture Notes in Computer Science), Vol. 1755. Springer, 208–220. Ernst W. Mayr. 1981. An Algorithm for the General Petri Net Reachability Problem. In Proceedings of STOC 1981. 238–246. Anca Muscholl, Helmut Seidl, and Igor Walukiewicz. 2017. Reachability for Dynamic Parametric Processes. In Verification, Model Checking, and Abstract Interpretation - 18th International Conference, VMCAI 2017, Paris, France, January 15-17, 2017, Proceedings (Lecture Notes in Computer Science), Vol. 10145. Springer, 424–441. Madanlal Musuvathi and Shaz Qadeer. 2007. Iterative context bounding for systematic testing of multithreaded programs. In Proceedings of the ACM SIGPLAN 2007 Conference on Programming Language Design and Implementation, PLDI 2007, San Diego, CA, USA, June 10-13, 2007. ACM, 446–455. Oded Padon, Jochen Hoenicke, Giuliano Losa, Andreas Podelski, Mooly Sagiv, and Sharon Shoham. 2018. Reducing liveness to safety in first-order logic. Proc. ACM Program. Lang. 2, POPL (2018), 26:1–26:33. Rohit J. Parikh. 1966. On Context-Free Languages. J. ACM 13, 4 (1966), 570–581. Shaz Qadeer and Jakob Rehof. 2005. Context-Bounded Model Checking of Concurrent Software. In Tools and Algorithms for the Construction and Analysis of Systems, 11th International Conference, TACAS 2005, Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2005, Edinburgh, UK, April 4-8, 2005, Proceedings (Lecture Notes in Computer Science), Vol. 3440. Springer, 93–107. Charles Rackoff. 1978. The covering and boundedness problems for vector addition systems. Theoretical Computer Science 6, 2 (1978), 223–231. Ganesan Ramalingam. 2000. Context-sensitive synchronization-sensitive analysis is undecidable. ACM TOPLAS 22(2) (2000), 416–430. Frank Plumpton Ramsey. 1930. On a Problem of Formal Logic. Proceedings of the London Mathematical Society s2-30, 1 (1930), 264–286. https://doi.org/10.1112/plms/s2-30.1.264 Salvatore La Torre, Margherita Napoli, and Gennaro Parlato. 2016. Scope-Bounded Pushdown Languages. Int. J. Found. Comput. Sci. 27, 2 (2016), 215–234. https://doi.org/10.1142/S0129054116400074 Moshe Y. Vardi. 1991. Verification of concurrent programs—the automata-theoretic framework. Annals of Pure and Applied Logic 51 (1991), 79–98. Kumar Neeraj Verma and Jean Goubault-Larrecq. 2005. Karp-Miller Trees for a Branching Extension of VASS. Discrete Mathematics & Theoretical Computer Science Vol. 7 (2005). Georg Zetzsche. 2013. Silent Transitions in Automata with Storage. (2013). arXiv:1302.3798 Full version of an article in Proceedings of ICALP 2013.

Context-Bounded Verification of Liveness: Conclusion, Acknowledgment & References

This paper is available on arxiv under CC BY-NC-SA 4.0 DEED license. Authors: (1) Pascal Baumann, Max Planck Institute for Software Systems (MPI-SWS), Germany; (2) Rupak Majumdar, Max Planck Institute for Software Systems (MPI-SWS), Germany; (3) Ramanathan S. Thinniyam, Max Planck Institute for Software Systems (MPI-SWS), Germany; (4) Georg Zetzsche, Max Planck Institute for Software Systems (MPI-SWS), Germany. Table of Links Introduction Dynamic Networks of Concurret Pushdown Systems (DCPS) Warm-up: Non-Termination Fair Non-Termination From Progressive Runs for VASSB to Reachability Starvation Conclusion, Acknowledgment & References A. Strengthening Fairness to Progressive Runs B. Proofs from Section 4.1 C. Proofs for Section 5 D. Proofs for Section 5.3 E. Proofs for Section 6 We study context-bounded verification of liveness properties of multi-threaded, shared-memory programs, where each thread can spawn additional threads. Our main result shows that context-bounded fair termination is decidable for the model; context-bounded implies that each spawned thread can be context switched a fixed constant number of times. Our proof is technical, since fair termination requires reasoning about the composition of unboundedly many threads each with unboundedly large stacks. In fact, techniques for related problems, which depend crucially on replacing the pushdown threads with finite-state threads, are not applicable. Instead, we introduce an extension of vector addition systems with states (VASS), called VASS with balloons (VASSB), as an intermediate model; it is an infinite-state model of independent interest. A VASSB allows tokens that are themselves markings (balloons). We show that context bounded fair termination reduces to fair termination for VASSB. We show the latter problem is decidable by showing a series of reductions: from fair termination to configuration reachability for VASSB and thence to the reachability problem for VASS. For a lower bound, fair termination is known to be non-elementary already in the special case where threads run to completion (no context switches). We also show that the simpler problem of context-bounded termination is 2EXPSPACE-complete, matching the complexity bound—and indeed the techniques—for safety verification. Additionally, we show the related problem of fair starvation, which checks if some thread can be starved along a fair run, is also decidable in the context-bounded case. The decidability employs an intricate reduction from fair starvation to fair termination. Like fair termination, this problem is also non-elementary. 1 INTRODUCTION We study decision problems related to liveness verification of shared-memory multithreaded programs. In a shared-memory multithreaded program, a number of threads execute concurrently. Each thread executes possibly recursive sequential code, and can spawn new threads for concurrent execution. The threads communicate through shared global variables that they can read and write. The execution of the program is guided by a non-deterministic scheduler that picks one of the spawned threads to execute in each time step. If the scheduler replaces the currently executing thread with a different one, we say the current active thread is context switched. Shared-memory multithreaded programming is ubiquitous and static verification of safety or liveness properties of such programs is a cornerstone of formal verification research. Indeed, there is a vast research literature on the problem—from a foundational understanding of the computability and complexity of (subclasses of) models, to program logics, and to efficient tools for analysis of real systems. In this paper, we focus on decidability issues for liveness verification for multithreaded shared memory programs with the ability to spawn threads. Liveness properties, intuitively, specify that “something good” happens when a program executes. A simple example of a liveness property is termination: the property that a program eventually terminates. In fact, termination is a “canonical” liveness property: for a very general class of liveness properties, through monitor constructions, verifying liveness properties reduces to verifying termination [Apt and Olderog 1991; Vardi 1991]. Unfortunately, under the usual notion of non-deterministic schedulers, some programs may fail to terminate for uninteresting reasons. Consider the following program: 1 global bit := 1; 2 main () { spawn foo ; spawn bar ; } 3 foo () { if bit = 1 then spawn foo ; } 4 bar () { bit := 0; } A main thread spawns two additional threads foo and bar. The thread foo checks if a global bit is set and, if so, re-spawns itself. The thread bar resets the global bit. There is a non-terminating execution of this program in which bar is never scheduled. However, a scheduler that never schedules a thread that is ready to run would be considered unfair. Instead, one formulates the problem of fair termination: termination under a fair non-deterministic scheduler. We abstract away from the exact mechanism of the scheduler, and only require that every spawned thread that is infinitely often ready to run is eventually scheduled. Then, every fair run of the above program is terminating: eventually bar is scheduled, after which foo does not spawn a new thread. Since the high undecidability relies on an unbounded exchange of information among threads, a recent and apposite approach to verifying concurrent recursive programs is to explore only a representative subset of program behaviors by limiting the number of inter-thread interactions [Musuvathi and Qadeer 2007; Qadeer and Rehof 2005]. This approach, called context bounding by Qadeer and Rehof [2005], considers the verification problem as a family of problems, one for each K. The K-context bounded instance, for any fixed K ≥ 0, considers only those executions where each thread is context switched at most K times by the scheduler. In the limit as K → ∞, the K-bounded approach explores all behaviors where each thread runs a finite number of times. In practice, bounded explorations with small values of K have proved to be effective to uncover many safety and liveness bugs in real systems. Our results generalize the special case of K = 0 studied by Ganty and Majumdar [2012] as asynchronous programs. When K = 0, each thread executes to completion without being interrupted in the middle. Ganty and Majumdar show the decidability of safety and liveness verification for this model. In particular, they prove safety and termination are both EXPSPACE-complete and fair termination and fair starvation are decidable but non-elementary.[2] Their proof depends on the observation that, since threads are not interrupted, one can replace the pushdown automata for each thread by finite automata that accept Parikh-equivalent languages. Unfortunately, their technique does not generalize when context switches are allowed. For K ≥ 1, Atig et al. [2009] showed that the safety verification problem is decidable in 2EXPSPACE. Ten years later, a matching lower bound was shown by Baumann et al. [2020]. The key observation in the decision procedure is that safety is preserved under downward closures: one can analyze a related program where some spawned threads are “forgotten.” Since the downward closure of a context free language is effectively regular, one can replace the pushdown automaton for each thread by a finite automaton accepting the downward closure. In fact, our proof of termination also follows easily from this observation, as termination is also preserved by downward closures. Unfortunately, fair termination and fair non-starvation are not preserved under downward closures. Thus, we cannot apply the preceding techniques to replace pushdown automata by finite automata in our construction. Thus, our proof is more intricate and requires several insights into the computational model. The key difficulty in our decision procedure is to maintain a finite representation for unboundedly many active threads, each with unboundedly large local stacks and potentially spawning unboundedly many new threads, and to compose their context-switched executions into a global execution. In order to maintain and compose such configurations, we introduce a new model, called VASS with balloons (VASSB), that extends the usual model of a vector addition systems with states (VASS) with “balloons”: a token in a VASSB can be a usual VASS token or a balloon token that is itself a vector. Intuitively, balloon tokens represent the possible new threads a thread can spawn along one of its execution segments. We show through a series of constructions that the fair termination problem reduces to the fair termination problem for VASSB, and thence to the configuration reachability problem for VASSB. Finally, we show that configuration reachability for VASSB is decidable by a reduction to the reachability problem for VASS. This puts VASSB in the rare class of infinite-state systems which generalize VASS and yet maintain a decidable reachability (not just coverability!) problem. Finally, we show a reduction from the fair starvation problem to fair termination. The reduction relies on two combinatorial insights. The first is that if a program has an infinite fair run, then it has one in which there exists a bound on the number of threads spawned by each thread. The second is a novel pumping argument based on Ramsey’s theorem; it implies that it suffices to track a finite amount of data about each thread to determine whether some thread can be starved. In conclusion, we prove decidability of liveness verification for multithreaded shared memory programs with the ability to dynamically spawn threads, an extremely expressive model of multithreaded programming. This model sits at the boundary of decidability and subsumes many other models studied before. Safety verification for concurrent recursive programs is already undecidable with just two threads and finite global store [Ramalingam 2000]. Many results on context-bounded safety verification consider a model with a fixed number of threads, without spawns. The complexity of safety verification for this model is well understood at this point. The key idea underlying the best algorithms reduce the problem to analyzing a sequential pushdown system [Lal and Reps 2009] by guessing the bounded sequences of context switches for each thread and using the finite state to ensure the sequential runs can be stitched together Related Work. When the model allows spawning of new threads, as ours does, existing decision procedures are significantly more complex, both in their technicalities and in computational cost. There are relatively few results on decidability of liveness properties of infinite-state systems. Atig et al. [2012a] show a sufficient condition for fair termination for context-bounded executions of a fixed number of threads, where they look for ultimately periodic executions, in which each thread is context switched at most K times in the loop. They show that the search for such ultimately periodic executions can be reduced to safety verification. In our model, fair infinite runs may involve unboundedly many threads with unbounded stacks and need not be periodic—for example, there can always be more and more newly spawned threads. Multi-pushdown systems model multithreaded programs with a fixed number of threads. Many decision procedures are known when the executions of such systems are restricted through different bounds such as context, scope, or phase [Atig et al. 2012b, 2017; Torre et al. 2016], and also through limitations on communication patterns [Lal et al. 2008]. These problems are orthogonal to us, either in the modeling capabilities or in the properties verified. Decidability of linear temporal logic is known for weaker models of multithreaded recursive programs, such as symmetric parameterized programs [Kahlon 2008] or leader-follower programs with non-atomic reads and writes [Durand-Gasselin et al. 2017; Fortin et al. 2017; Muscholl et al. 2017]. These programs cannot perform compare-and-swap operations, and therefore, their computational power is quite limited (in fact, LTL model checking is PSPACE-complete). A number of heuristic approaches to fair termination of multithreaded programs provide sound but incomplete algorithms, but for a more general class of programs involving infinite-state data variables [Cook et al. 2007, 2011; Farzan et al. 2016; Kragl et al. 2020; Padon et al. 2018]. The goal there is to provide a sound proof rule for verification but not to prove a decidability result. In terms of fair termination problems for VASS, the theme of computational hardness continues. For example, the classical notion of fair runs, in which an infinitely activated transition has to be fired infinitely often, leads to undecidability [Carstensen 1987] and even Σ 1 1 - completeness [Howell et al. 1991]. However, weakly fair termination, where only those transitions that are almost always activated have to be fired infinitely often, is decidable [Jančar 1990]. A rich taxonomy of fairness notions with corresponding decidability results can be found in [Howell et al. 1991]. However, all of these notions appear to be incomparable with our fairness notion for VASSB. Our model of VASSB treads the boundary of models that generalize VASS for which reachability can be proved to be decidable. We note that there are several closely related models, VASS with a stack [Leroux et al. 2015] and branching VASS [Verma and Goubault-Larrecq 2005], for which decidability of reachability is a long-standing open problem, and others, nested Petri nets [Lomazova and Schnoebelen 1999], for which reachability is undecidable. [1] Recall that the class Π 1 1 in the analytic hierarchy is the class of all relations on N that can be defined by a universal second-order number-theoretic formula. [2] Their result shows a polynomial-time equivalence between fair termination and reachability in vector addition systems with states (VASS, a.k.a. Petri nets). The complexity bounds follow from our current knowledge of the complexity of VASS reachability [Czerwinski et al. 2019].

Context-Bounded Verification of Liveness Properties for
Multithreaded Shared-Memory Programs: Intro

If you’re using dynamically created components in Angular, you’ve probably found it difficult to pass information between the parent and child components when needed. You need to provide the info in the parent, and then inject it within the child component. While it’s not necessarily difficult to do, it results in a lot of extra boilerplate code. It would be so much better if we could just use the decorator like we’re used to. Well, guess what? Angular supports doing this exact thing as of version sixteen. In this post, I’ll show you how. Alright, let’s get to it. @Input https://youtu.be/MT2JP8pn1qU?embedable=true Passing Data the Old Way Using the Angular Injector First, let’s look at how we used to pass data to dynamically created components from the parent. Here, in this example, within the component template, we have our , and we’re passing it to our player component. *ngComponentOutlet In this case, we’re also passing a custom child injector, and this is how we’d inject the data for the child component before. main.ts @Component({
 selector: 'app-root',
 template: `
 <ng-container *ngComponentOutlet="playerComponent; injector: childInjector"></ng-container>
 `
})
export class App {
 protected playerComponent = PlayerComponent;
} And to create this child injector, we needed to create a property so that it could be set and then used within the template. export class App {
 protected childInjector?: Injector;
 ...
} Then, we needed to inject in the Injector from the angular core within the constructor. export class App {
 ...
 constructor(private injector: Injector) {
 }
} After that, we needed to set the child injector using the create method and the providers’ array to provide our player token to the child. export class App {
 ...
 constructor(private injector: Injector) {
 this.childInjector = Injector.create({
 providers: [
 { provide: PlayerToken, useValue: this.player }
 ],
 parent: this.injector
 });
 }
} And finally, over in the child component, our player component, we needed to set our player property with the inject method from the angular core. player.component.ts export class PlayerComponent {
 protected player?: Player = inject(PlayerToken);
} So, all of this is just to pass a simple player object to a dynamic component. I mean, if this wasn’t a dynamic component, we’d simply make this an and just bind the player data object to the in the parent. But this is a dynamically created component, so we can’t do this, right? @Input @Input Well, as of Angular sixteen, we actually can use s instead, and it’s much simpler than what we’ve seen so far. @Input Passing Data the New Way Using the Inputs Object *ngComponentOutlet We start by changing this player property to an instead. And, it’s simply typed into our player interface. @Input player.component.ts export class PlayerComponent {
 @Input() player?: Player;
} Now, we can remove the inject method and player token imports since they’re no longer needed. Then, back over in our parent, in the template, we can remove the injector, and instead, replace it with an inputs object. We can pass this object on any number of inputs. So, if we had five inputs, we’d just include their names, and then pass each one whatever data we need. But in this case, we have only one input on our child component, player, so that’s all we need to pass it. main.ts @Component({
 selector: 'app-root',
 template: `
 <ng-container *ngComponentOutlet="playerComponent; inputs: { player }"></ng-container>
 `
}) Now, we can remove the child injector. This means we can also remove the constructor altogether. And finally, we can remove the Injector from the angular core and the player token import since we’re no longer using them. export class App {
 protected player: Player = {
 name: 'LeBron James',
 games: 1421,
 points: 38652,
 fieldGoalPercentage: 0.505,
 threePointPercentage: 0.345,
 imageName: 'lebron-james'
 };
 protected playerComponent = PlayerComponent;
} And that’s it. We can see everything works just as it used to. So, quite a bit easier to pull off and less code too which is always great. One bummer though is that while s are supported, s aren’t. Kind of a bummer, but it is what it is. Hopefully, they’ll add support in the future because this would be very handy as well, but we’ll just have to wait and see. @Input @Output Want to See It in Action? Check out the demo code and examples of these techniques in the Stackblitz example below. If you have any questions or thoughts, don’t hesitate to leave a comment. https://stackblitz.com/edit/stackblitz-starters-9xzkkf?ctl=1&embed=1&file=src%2Fmain.ts&embedable=true

How to Use Angular @Input to Pass Data to Dynamically Created Components

গতিশীলভাবে তৈরি উপাদানগুলিতে ডেটা পাস করতে কৌণিক @ইনপুট কীভাবে ব্যবহার করবেন

So verwenden Sie Angular @Input, um Daten an dynamisch erstellte Komponenten zu übergeben

Cómo utilizar Angular @Input para pasar datos a componentes creados dinámicamente

Comment utiliser Angular @Input pour transmettre des données à des composants créés dynamiquement

गतिशील रूप से निर्मित घटकों में डेटा पास करने के लिए Angular @Input का उपयोग कैसे करें

Angular @Input を使用して動的に作成されたコンポーネントにデータを渡す方法

Angular @Input을 사용하여 동적으로 생성된 구성 요소에 데이터를 전달하는 방법

Como usar Angular @Input para passar dados para componentes criados dinamicamente

Как использовать Angular @Input для передачи данных в динамически создаваемые компоненты

Dinamik Olarak Oluşturulan Bileşenlere Veri Aktarmak için Angular @Input Nasıl Kullanılır

Cách sử dụng @Input góc để truyền dữ liệu đến các thành phần được tạo động

如何使用 Angular @Input 将数据传递给动态创建的组件

In the latest version of Angular, we’re getting what is known as the new Control Flow syntax for our component templates. It will replace older directives for things like , , and *ngIf/else ngSwitch *ngFor In this post, we’re going to learn exactly what this change means for us and how to use it. Alright, let’s get to it. https://youtu.be/nUEERAOZKwg?embedable=true So, for those of us that are used to building things in Angular, we’re used to the structural directive , and the concept of using an for the else condition when needed. Well, we don’t need this anymore with the new Control Flow syntax. *ngIf ng-template Also, we no longer need to import the to use them. Let’s take a look at an example. CommonModule Angular Control Flow Syntax for If/Else Conditions Ok, here in our component we have this player object consisting of some data about NBA player LeBron James. app.component.ts protected player: Player = {
 name: 'LeBron James',
 games: 1421,
 points: 38652,
 fieldGoalPercentage: 0.505,
 threePointPercentage: 0.345,
 imageName: 'lebron-james'
}; If we were to imagine that, in the real world, data like this may come from an API request where it may contain data or just be undefined. We would then need to conditionally use it within our template. In this case, we want to show our player component and pass it the player data only when it’s been defined. So, we need to use an if condition. For the new syntax, it’s similar to other templating languages like PHP, razor, and others. We start with the symbol, then in parentheses, we add our condition. Here, it will be if our player value is truthy, and then we wrap whatever conditional item. In this case, it’s our player component, with a player input, and that’s it. @ app.component.html @if (player) {
 <app-player [player]="player"></app-player>
} Right now, of course, it’s showing because we have our data hard-coded. So, let’s go clear it out. protected player?: Player; And, when we save, now we can see that it’s properly removed when no data is provided. If we want to show a message when we have no data, we need to add an else statement. To do this, we just need to add another symbol, then the word "else", then a new set of curly braces where we wrap our message. @ @if (player) {
 <app-player [player]="player"></app-player>
} @else {
 No player exists at this time
} Then, when we save this, we see that our message is properly displayed because we now have no data. So, that’s the new syntax replacing the old . *ngIf/else Angular Control Flow Syntax for Switch Statements Next up, we have the new syntax for switch statements. We no longer need a wrapping element or in order to use an directive and each of its cases. In this example, we have a select control where we can choose Lebron, Kareem, or leave it as the default player. ng-container ngSwitch And, when we look at our data, we have three player objects, player one, LeBron, player two, Kareem, and player three, Karl Malone. protected player1: Player = {
 name: 'LeBron James',
 games: 1421,
 points: 38652,
 fieldGoalPercentage: 0.505,
 threePointPercentage: 0.345,
 imageName: 'lebron-james'
};
protected player2: Player = {
 name: 'Kareem Abdul-Jabbar',
 games: 1560,
 points: 38387,
 fieldGoalPercentage: 0.559,
 threePointPercentage: 0.056,
 imageName: 'kareem-abdul-jabbar'
};
protected player3: Player = {
 name: 'Karl Malone',
 games: 1476,
 points: 36928,
 fieldGoalPercentage: 0.516,
 threePointPercentage: 0.274,
 imageName: 'karl-malone'
}; What we want to do in the template is show the appropriate player to match the value of our form control. This control will be a value of a string matching either Lebron, Kareem, or Default. protected options = new FormControl<'LeBron' | 'Kareem' | 'Default'>('Default', { nonNullable: true }); So, back in our template, we’ll begin by adding the symbol followed by the word "switch", then in parentheses, the value that we’ll want to switch on, in this case, that will be our options control value. @ @switch (options.value) {} Now, for our first case, we add the symbol, then the word "case", followed by the value, LeBron for this case, in parentheses. Then, within curly braces, we add our player component with the player input, in this case, it will be player one because that was Lebron in our data. @ @switch (options.value) {
 @case ('LeBron') {
 <app-player [player]="player1"></app-player>
 }
} Now, we can simply copy all of this, paste it, then change the case to Kareem, and the input to player two this time for Kareem’s data. @switch (options.value) {
 @case ('LeBron') {
 <app-player [player]="player1"></app-player>
 }
 @case ('Kareem') {
 <app-player [player]="player2"></app-player>
 }
} And then, finally, we can add our default case. We’ll add the player component one last time here, and we'll pass it to player three for Karl Malone. @switch (options.value) {
 @case ('LeBron') {
 <app-player [player]="player1"></app-player>
 }
 @case ('Kareem') {
 <app-player [player]="player2"></app-player>
 }
 @default {
 <app-player [player]="player3"></app-player>
 }
} Ok, now when we save, we see Karl Malone since he was the default, and our control value is set to default when initialized. If we change to Lebron, the view is properly updated. And likewise with Kareem. So, that’s the new switch syntax; up next, we have the final example in this post, a for loop. Angular Control Flow Syntax for For Loops When adding for loops in angular, we used to need an element or for our directive. Then we would need to create a variable from a list of options, and then much of the time, we needed to add a function to help with performance. Well, it looks similar now but a little different. ng-container *ngFor trackby In this example, our list of players is larger and consists of all of these items. players.ts export const players = [
 {
 name: 'LeBron James',
 games: 1421,
 points: 38652,
 fieldGoalPercentage: 0.505,
 threePointPercentage: 0.345,
 imageName: 'lebron-james'
 },
 {
 name: 'Kareem Abdul-Jabbar',
 games: 1560,
 points: 38387,
 fieldGoalPercentage: 0.559,
 threePointPercentage: 0.056,
 imageName: 'kareem-abdul-jabbar'
 },
 {
 name: 'Karl Malone',
 games: 1476,
 points: 36928,
 fieldGoalPercentage: 0.516,
 threePointPercentage: 0.274,
 imageName: 'karl-malone'
 },
 {
 name: 'Kobe Bryant',
 games: 1346,
 points: 33643,
 fieldGoalPercentage: 0.447,
 threePointPercentage: 0.329,
 imageName: 'kobe-bryant'
 },
 {
 name: 'Michael Jordan',
 games: 1072,
 points: 32292,
 fieldGoalPercentage: 0.497,
 threePointPercentage: 0.327,
 imageName: 'michael-jordan'
 },
 {
 name: 'Dirk Nowitzki',
 games: 1522,
 points: 31560,
 fieldGoalPercentage: 0.471,
 threePointPercentage: 0.38,
 imageName: 'dirk-nowitzki'
 },
 {
 name: 'Wilt Chamberlain',
 games: 1045,
 points: 31419,
 fieldGoalPercentage: 0.54,
 threePointPercentage: 0,
 imageName: 'wilt-chamberlain'
 },
 {
 name: 'Shaquille O\'Neal',
 games: 1207,
 points: 28596,
 fieldGoalPercentage: 0.582,
 threePointPercentage: 0.045,
 imageName: 'shaquille-oneal'
 },
 {
 name: 'Carmelo Anthony',
 games: 1260,
 points: 28289,
 fieldGoalPercentage: 0.447,
 threePointPercentage: 0.355,
 imageName: 'carmelo-anthony'
 },
 {
 name: 'Moses Malone',
 games: 1329,
 points: 27409,
 fieldGoalPercentage: 0.491,
 threePointPercentage: 0.10,
 imageName: 'moses-malone'
 },
 {
 name: 'Elvin Hayes',
 games: 1303,
 points: 27313,
 fieldGoalPercentage: 0.452,
 threePointPercentage: 0.147,
 imageName: 'elvin-hayes'
 }
]; We want to list these players out in the template with a for loop. So, we start by adding the symbol again. Then, the word "for" is followed by parentheses. In these parentheses, we create our variable, we’ll call it "player." @ Then, like the old , we use the word "of", followed by our variable for our list of data, in this case, players. *ngFor @for (player of players) {
} Now, one of the key differences in the new syntax is that a track expression is mandatory. So, if we were to save this, we get an error letting us know what we’re missing. So, we need to add a semi-colon, followed by the word "track." Then we need to provide a unique value to track, something like an ID, but in our case, we’ll use the player name. @for (player of players; track player.name) {
} Ok, all that’s left now is to add our player component and pass it our player data. @for (player of players; track player.name) {
 <app-player [player]="player"></app-player>
} And now when we save, there’s our list of players. Angular For Loop Empty Template Now, what if our list was empty, and we wanted to show a message? Well, let’s clear out our list data. If we were to save right now, we'd just have a blank screen. To show a message in this case, back in our template, we can add an empty scenario for our for loop. And inside, we can add our message. @for (player of players) {
 ...
}
@empty {
 There are no players to display at this time
} Now, when we save, we see our message. Pretty easy, right? Angular For Loop Additional Properties Now, for those of you familiar with the old , you may be wondering about all of the old properties that we had available: *ngFor index first last even odd count Well, they all still exist in the new syntax too. We just add them much like we did before. We use the word "let" followed by the variable name we want to use, then equals and the name of the value prefixed with a dollar sign. @for (player of players;
 track player.name;
 let index = $index;
 let first = $first;
 let last = $last;
 let even = $even;
 let odd = $odd;
 let count = $count) {
 ...
} So, after adding all of these, let's say we want to display the count in a message before the first item in the list. So, we add a condition for the first item, then add a message with the string interpolated value for the list count. @if (first) {
 There are {{ count }} players in the list
} When we save, now we can see the message with the count before all items. And, let’s say we want to display the list item number next to the player name. We can do this by passing the item index to the player component. <app-player
 ...
 [index]="index"
 ...>
</app-player> Internally, this component adds one to its index value and places the string interpolated value before the name. We could also add some zebra striping by binding a class, even, to all of the even-numbered list items. <app-player
 ...
 [class.even]="even"
 ...>
</app-player> Now, we can see all of the even items are a little darker. And finally, we can highlight the first and last list items by binding a first and last class to those variables. <app-player
 ...
 [class.first]="first"
 [class.last]="last"
 ...>
</app-player> Here, we can see the first item gets a red border. And, when we scroll down to the bottom, the last item gets a blue border. Pretty straightforward, right? So, I think this is a pretty nice change. It’s pretty similar to what we’re used to but it’s a little more simple. It doesn’t require as many elements, s, and s, and it also doesn’t require any imports which is pretty nice. ng-container ng-template I guess, some things are simpler, some things are easier, and some things are just different. The Angular Control Flow Migration Schematic For those of you who may be worried about making this change to an existing codebase, don’t be. To migrate all of your existing s, s, and s, you can simply use the migration schematic which should hopefully update them without much work. *ngIf ngSwitch *ngFor ng g @angular/core:control-flow-migration Ok, so that’s pretty much all I have for Angular’s new control flow syntax. Want to See It in Action? Check out the demo code and examples of these techniques in the stackblitz example below. If you have any questions or thoughts, don’t hesitate to leave a comment. https://stackblitz.com/edit/ttnwwm?ctl=1&embed=1&file=src%2Fapp%2Fapp.component.ts&embedable=true

A Beginner-Friendly Guide On How to Use Angular's New Control Flow Syntax

Since the inception of The Naked Collector in 2021, I’ve been one of the leading voices in Web3 consumer and specifically Web3 fashion research. My , has attracted a loyal following from industry giants, including  H&M, Harvard Business School, Adidas, JP Morgan and Coinbase. private newsletter Today, I'm thrilled to unveil the enigmatic world of Web3 fashion and corporate (Web2) NFTs to a wider audience. As a recognized authority in this niche, I've had the unique privilege of observing and shaping emerging trends, which positions me ideally to present these awards. The awards represent the innovative spirit and transformative potential of Web3. They serve to acknowledge remarkable contributions and groundbreaking advancements in this rapidly evolving field. Best Web3 Success Story: Pudgy Penguins In April 2022, Pudgy Penguins was considered a dead project. However, under the new leadership of Luca Netz, the brand has undergone remarkable innovation and growth. This resurgence is best exemplified by the introduction of Pudgy Penguin Toys, now shelved in 2000 Walmart stores. These toys not only offer physical enjoyment but also unlock unique NFT traits, including clothing, which users can interact with and trade online. A key to their success is the strategic use of NFTs as Intellectual Property (IP) to generate revenue. Pudgy Penguins from May to the end of the year, demonstrating a lucrative intersection between physical products and digital assets. What sets them apart is their approach to community engagement; Pudgy Toys are licensed directly from the community, marking a pioneering move in the market. anticipates toy sales to reach approximately $10 million In 2023, the brand expanded its portfolio by launching Pudgy Toys and the IGLOO fashion line. Looking ahead to 2024, Pudgy Penguins is set to join the ranks of BAYC, Azuki, and RTFKT by launching its own metaverse, "Pudgy World." Best Web2* (Fashion) Success Story: PUMA Puma NFT collections went largely under the radar but amassed 4th largest volume among Web2 brand NFTs (after DraftKings, Nike and Porsche). Notably, while PUMA's revenue in the traditional sportswear market reached only 35% of Adidas' revenue, its 2023 NFT sales volume impressively exceeded that of Adidas by 450%. Furthermore, PUMA's Web3 royalties achieved 73% of Adidas' figures. A notable aspect of PUMA's NFT success is its ability to attract new participants in the digital asset space. Approximately 33% of its NFT buyers were beginners (wallets with less than 10 transactions), compared to the average of 18% across both Web3 fashion and other Web2 brand NFT collections. This statistic underscores PUMA's role in expanding the reach and appeal of NFTs beyond the traditional market. Best Web2 (Non-Fashion) Success Story: DraftKings DraftKings has emerged as a leader in the non-fashion Web2 space, thanks to its NFT-enabled fantasy games, including Reignmakers Football, UFC, & PGA Tour. The NFTs are minted on the Polygon blockchain and DraftKings games have amassed the largest NFT volume in 2023 among all Web2 brands. According to CryptoSlam data, the collections accumulated a total volume of $251,409,713 since February (as of December 2023). This achievement ranks them as the 25th most traded NFT collection of all time in less than a year, with over 120,000 holders. Notably, the collection also secured the highest royalties among Web2 brands, totaling $25 million. A key strategy of DraftKings has been targeting regular users, especially those not native to the Web3 space. By trading on the Polygon blockchain and simplifying the process – such as allowing payment for NFTs with credit cards and minimizing Web3 complexities like gas fees and cryptocurrencies – they have made their platform more accessible. Additionally, DraftKings' ownmarketplace facilitates these trades, from which the company garners a 10% marketplace fee. Given the projected growth of the U.S. online sports betting market – estimated to reach an annual $12.5 billion by 2025, up from $6.8 billion in 2022 (Stifel Research) – and the inherent suitability of NFTs for fantasy sports, DraftKings' volume is expected to continue its upward trajectory. Web2 Brand With Most Holders (Users): Reddit As of December 2023, Reddit had the most NFT holders with 24.9M, according to Polygon Analytics). For comparison, below is the holder situation in October 2023, from . The Naked Collector Fashion in Web3 Industry Report Biggest Disappointment: RTFKT Despite being at the forefront of merging Web3 with fashion technology and gaining publicity through endorsements from celebrities, RTFKT emerges as the year's biggest disappointment, primarily due to the lofty expectations placed upon it. While Nike’s own native dotSWOOSH ID collection saw 376,000 holders mint the ID, RTFKT saw its performance numbers decline. While RTFKT continued to dominate the fashion volume charts for the second consecutive year, the market witnessed a significant decline in the value of its collections. The Clone X floor price, for instance, plummeted from $8.5K in February 2023 (and an all-time high of $67K in April 2022) to just over $3K by December 2023. The most affected were holders of secondary collections such as CryptoKicks, EVO X Vials, MNLTHs, Trillium Lace Engines and Loot Pods, primarily due to their redeemable nature — a development that caught many by surprise. some of which lost nearly all value RTFKT’s downturn can be partly attributed to delays in production processes. However, a larger factor was the misalignment between holder expectations and project delivery, exacerbated by insufficient communication (from many holders’ point of view). The floor price, a reflection of current and projected sentiment, suggests that if RTFKT successfully advances its Wear to Earn technology and metaverse ecosystem, it could positively influence both the floor prices and the overall sentiment around the project. There have also been glimpses of RTFKT’s potential for mainstream adoption, evidenced by LeBron James wearing theRTFKT x Nike Air Force 1 - Genesis sneakers and DJ Khaled sporting the Nike x RTFKT AR Hoodie. Whether the same holders who supported RTFKT from the beginning will still be here, is another question. Most Surprising Web2 Brand Entry: Maison Margiela Maison Margiela marked its entry into the Web3 space with a unique and surprising move, launching its first gamified minting experience on October 24. Participants were given the chance to collect 24 distinctly numbered digital tokens, numbered from 0 to 23. This innovative endeavor utilized "Polygon Soul-Bound Tokens," which are non-transferable and allowed each participant to mint only one of each type. The experience was gas-free, emphasizing user accessibility and ease. The competition, designed to be fast-paced and equitable, was set to conclude once all 100 numbers were minted. Despite its intriguing approach to gamifying FOMO (fear of missing out), the minting experience garnered some negative feedback, particularly concerning its perceived difficulty. Biggest Fashion Trend: Phygitals one of the most significant trends in fashion NFTs this year has been the rise of 'phygitals' – physical fashion items linked to NFTs through embedded NFC or RFID chips. This trend aligns with the growing narrative around RWAs (real-world assets) within the broader crypto space, indicating a continuing expansion in the future. As predicted in 2022, In 2023, underscoring their rising popularity. The next evolution of this trend is expected to involve the integration of real-world data, such as ESG and sports data, through oracles. Other anticipated developments include the collateralization of high-value items, like luxury watches, and the introduction of physical-to-digital perks, exempli ed by concepts like 'wear to earn.' phygitals emerged as the most popular product release category among Web2 fashion brands, (From The Naked Collector Fashion in Web3 Industry Report) Largest Avg. Profit in 2023 (Web2 fashion collection):Nike/RTFKT CloneX Mintvial ($1,751) Largest Avg. ROI in 2023 (Web3 fashion collection): A Kid Called Beast ($684) The "A Kid Called Beast" (AKCB) collection has emerged as a standout in the 2023 Web3 fashion sector. This collection features 9,999 unique, 3D characters that are ready for augmented reality, hosted on the Ethereum blockchain. Each character belongs to one of 20 distinct "beasthoods," symbolizing various personality traits and emphasizing the collection's focus on fashion and cultural representation. Gaining traction on platforms like OpenSea, AKCB's innovative approach to distribution and its strong identity as a Web3 brand have been pivotal in fostering a robust community around these digital collectibles. Secondary Volume in 2023 (Web2 vs. Web3 Fashion) We can see that Web2 brands dominated the fashion NFT volume in 2023. This dominance was evident not only in the absolute volume of transactions but also in the average volume per collection. The data analyzed included 46 Web2 and 31 Web3 NFT collections, representing an 11% difference in the number of collections. However, the disparity in volume was far more significant, with a 106% higher volume for Web2 brands compared to their Web3 counterparts. This substantial difference underscores the prevailing influence of Web2 entities in the fashion NFT space. Secondary Volume in 2023 (All Web2 brands) When it comes to Web2 brand volume in 2023 (including non-fashion NFTs), DraftKings and Nike/RTFKT have established a clear lead over their competitors. Their performance notably overshadowed even the highly publicized Starbucks collection. It's important to acknowledge that both DraftKings and Nike/RTFKT bene ted from having a substantial supply of collections, a factor that likely contributed to their dominant positions in the market. Brand Primary Volume (Web2 Fashion) Nike is not only leading in secondary volume but primary (or mint) volume as well. Phygital Fashion Secondary Volume in 2023 (Web2 & Web3 Fashion) Nike/RTFKT is also the leader in phygital NFT secondary volume having three of their collections in the top 5. The most noteworthy is their Clone X Forging SZN 1, which saw 45.4K items forged, making it the largest phygital collection to date in terms of both volume and size. Additionally, their collaboration with RIMOWA for a phygital luggage collection ranked third in volume. The innovative cIRL sneakers, equipped with Wear to Earn functionality, placed fourth. 10KTF, a Web3 native brand, also made its mark in the top 5 with their Kagami phygital digital displays linked to their parent PFP collection. Meanwhile, PUMA's Materializer, an NFT representing a physical pair of shoes claimable in 2023, topped off the list. Highest Royalties in 2023 (All Web2 Brands): DraftKings ($25.1M) DraftKings had the highest Web2 royalties despite having the second largest volume, mainly due to their 10% marketplace fee. Highest Royalties in 2023 (Web3 Fashion): A Kid Called Beast ($1.8M) Want to Read More? Go to , to read how you can access the full report including Web3 user insights. https://thenakedcollector.substack.com/p/2023-recap-2023-2024-data-based-web3 Disclaimer The data in this report was generated directly by me through SQL queries on the Flipside Crypto platform This report is for informational purposes only. The information is as of its publication date and may change without notice. The publisher accepts no liability for any actions taken on the basis of the information provided. You are encouraged to share this report with others! The only request is to attribute the work to the author, The Naked Collector, in any sharing or reproduction of this material. When sharing digitally, please tag The Naked Collector or reference this work by citing the author properly. This report promotes the respectful exchange of information and acknowledges the hard work and expertise that went into creating this report. Thank you for your cooperation and understanding. Also published . here

And the Web3 Award Goes To...

এবং Web3 অ্যাওয়ার্ড যায়...

Und der Web3 Award geht an...

Y el premio Web3 es para...

Et le prix Web3 est décerné à...

और Web3 पुरस्कार जाता है...

そしてWeb3賞は…

그리고 Web3 상은 다음으로 향합니다...

E o prêmio Web3 vai para...

И награда Web3 достаётся...

Ve Web3 Ödülünün Sahibi...

Và giải thưởng Web3 thuộc về...

Web3 奖颁发给...

This paper is available on arxiv under CC BY-NC-SA 4.0 DEED license. Authors: (1) Shanshan Han & Qifan Zhang, UCI; (2) Wenxuan Wu, Texas A&M University; (3) Baturalp Buyukates, Yuhang Yao & Weizhao Jin, USC; (4) Salman Avestimehr, USC & FedML. Table of Links Abstract and Introduction Problem Setting The Proposed Two-Stages Anomaly Detection Verifiable Anomaly Detection using ZKP Evaluations Related Works Conclusion & References 7 CONCLUSION We present a cutting-edge anomaly detection technique specifically designed for the real-world FL systems. Our approach utilizes an early cross-round check that activates subsequent anomaly detection exclusively in the presence of attacks. When attacks happen, our approach removes anomaly client models efficiently, ensuring that the local models submitted by benign clients remain unaffected. Further, by leveraging ZKPs, participating clients get to verify the integrity of the anomaly detection and removal performed by the server. The practical design and the inherent efficiency of our approach make it well-suited for real-world FL systems. Our plans for future works include extending our approach to asynchronous FL and vertical FL scenarios. REFERENCES T. Aoki. On the stability of the linear transformation in banach spaces. Journal of the Mathematical Society of Japan, 2(1-2):64–66, 1950. E. Bagdasaryan, A. Veit, Y. Hua, D. Estrin, and V. Shmatikov. How to backdoor federated learning. In AISTATS, 2020a. Eugene Bagdasaryan, Andreas Veit, Yiqing Hua, Deborah Estrin, and Vitaly Shmatikov. How to backdoor federated learning. In International Conference on Artificial Intelligence and Statistics, pp. 2938–2948. PMLR, 2020b. Arjun Nitin Bhagoji, Supriyo Chakraborty, Prateek Mittal, and Seraphin Calo. Analyzing federated learning through an adversarial lens. In International Conference on Machine Learning, pp. 634– 643. PMLR, 2019. P. Blanchard, E. M. El Mhamdi, R. Guerraoui, and J. Stainer. Machine learning with adversaries: Byzantine tolerant gradient descent. In NeurIPS, 2017. David Byrd and Antigoni Polychroniadou. Differentially private secure multi-party computation for federated learning in financial applications. In Proceedings of the First ACM International Conference on AI in Finance, pp. 1–9, 2020. Sebastian Caldas, Sai Meher Karthik Duddu, Peter Wu, Tian Li, Jakub Konecnˇ y, H Brendan McMa- ` han, Virginia Smith, and Ameet Talwalkar. Leaf: A benchmark for federated settings. arXiv preprint arXiv:1812.01097, 2018. Xiaoyu Cao and Neil Zhenqiang Gong. Mpaf: Model poisoning attacks to federated learning based on fake clients. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 3396–3404, 2022. Xiaoyu Cao and Neil Zhenqiang Gong. Mpaf: Model poisoning attacks to federated learning based on fake clients. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 3396–3404, 2022. Xiaoyu Cao, Zaixi Zhang, Jinyuan Jia, and Neil Zhenqiang Gong. Flcert: Provably secure federated learning against poisoning attacks. IEEE Transactions on Information Forensics and Security, 17: 3691–3705, 2022. Mingqing Chen, Rajiv Mathews, Tom Ouyang, and Franc¸oise Beaufays. Federated learning of outof-vocabulary words. arXiv preprint arXiv:1903.10635, 2019. Y. Chen, L. Su, and J. Xu. Distributed statistical machine learning in adversarial settings: Byzantine gradient descent. ACM on Measurement and Analysis of Computing Systems, 1(2):1–25, 2017. Alexander Chowdhury, Hasan Kassem, Nicolas Padoy, Renato Umeton, and Alexandros Karargyris. A review of medical federated learning: Applications in oncology and cancer research. In Brainlesion: Glioma, Multiple Sclerosis, Stroke and Traumatic Brain Injuries: 7th International Workshop, BrainLes 2021, Held in Conjunction with MICCAI 2021, Virtual Event, September 27, 2021, Revised Selected Papers, Part I, pp. 3–24. Springer, 2022. M. Fang, X. Cao, J. Jia, and N. Gong. Local model poisoning attacks to Byzantine-robust federated learning. In USENIX Security, 2020. B. Feng, L. Qin, Z. Zhang, Y. Ding, and S. Chu. ZEN: An optimizing compiler for verifiable, zero-knowledge neural network inferences. 2021. Cryptology ePrint Archive. Grant S Fletcher. Clinical epidemiology: the essentials. Lippincott Williams & Wilkins, 2019. R. Freivalds. Probabilistic machines can use less running time. In IFIP Congress, 1977. Shuhao Fu, Chulin Xie, Bo Li, and Qifeng Chen. Attack-resistant federated learning with residualbased reweighting. arXiv preprint arXiv:1912.11464, 2019. Clement Fung, Chris JM Yoon, and Ivan Beschastnikh. The limitations of federated learning in sybil settings. In RAID, pp. 301–316, 2020. S. Goldwasser, S. Micali, and C. Rackoff. The knowledge complexity of interactive proof systems. SIAM Jour. on Comp., 18(1):186–208, 1989. J. Groth. On the size of pairing-based non-interactive arguments. In Eurocrypt, 2016. Rachid Guerraoui, Sebastien Rouault, et al. The hidden vulnerability of distributed learning in ´ byzantium. In International Conference on Machine Learning, pp. 3521–3530. PMLR, 2018. S. Han, H. Wang, J. Wan, and J. Li. An iterative scheme for leverage-based approximate aggregation. In IEEE ICDE, 2019. Shanshan Han, Baturalp Buyukates, Zijian Hu, Han Jin, Weizhao Jin, Lichao Sun, Xiaoyang Wang, Chulin Xie, Kai Zhang, Qifan Zhang, et al. Fedmlsecurity: A benchmark for attacks and defenses in federated learning and federated llms. arXiv preprint arXiv:2306.04959, 2023. Andrew Hard, Kanishka Rao, Rajiv Mathews, Swaroop Ramaswamy, Franc¸oise Beaufays, Sean Augenstein, Hubert Eichner, Chloe Kiddon, and Daniel Ramage. Federated learning for mobile ´ keyboard prediction. arXiv preprint arXiv:1811.03604, 2018. Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016. L. He, S. P. Karimireddy, and M. Jaggi. Byzantine-robust decentralized learning via self-centered clipping. 2022. Available on arXiv:2202.01545. Xiao Jin, Pin-Yu Chen, Chia-Yi Hsu, Chia-Mu Yu, and Tianyi Chen. Cafe: Catastrophic data leakage in vertical federated learning. Advances in Neural Information Processing Systems, 34:994–1006, 2021. Sai Praneeth Karimireddy, Lie He, and Martin Jaggi. Byzantine-robust learning on heterogeneous datasets via bucketing. arXiv preprint arXiv:2006.09365, 2020. Sanjay Kariyappa, Chuan Guo, Kiwan Maeng, Wenjie Xiong, G. Edward Suh, Moinuddin K. Qureshi, and Hsien-Hsin S. Lee. Cocktail party attack: Breaking aggregation-based privacy in federated learning using independent component analysis. In International Conference on Machine Learning, 2022. URL https://api.semanticscholar.org/CorpusID: 252211968. Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 2009. Maximilian Lam, Gu-Yeon Wei, David Brooks, Vijay apa Reddi, and Michael Mitzenmacher. Gradient disaggregation: Breaking privacy in federated learning by reconstructing the user participant matrix. In International Conference on Machine Learning, pp. 5959–5968. PMLR, 2021. S. Lee, H. Ko, J. Kim, and H. Oh. vCNN: Verifiable convolutional neural network based on zksnarks. 2020. Cryptology ePrint Archive. David Leroy, Alice Coucke, Thibaut Lavril, Thibault Gisselbrecht, and Joseph Dureau. Federated learning for keyword spotting. In IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 6341–6345, 2019. Suyi Li, Yong Cheng, Wei Wang, Yang Liu, and Tianjian Chen. Learning to detect malicious clients for robust federated learning. arXiv preprint arXiv:2002.00211, 2020. T. Liu, X. Xie, and Y. Zhang. ZkCNN: Zero knowledge proofs for convolutional neural network predictions and accuracy. In ACM CCS, 2021. A. Lyon. Why are normal distributions normal? The British Journal for the Philosophy of Science, 65(3):621–649, 2014. Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Aguera y Arcas. Communication-efficient learning of deep networks from decentralized data. In Artificial intelligence and statistics, pp. 1273–1282. PMLR, 2017a. Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Aguera y Arcas. Communication-efficient learning of deep networks from decentralized data. In Artificial intelligence and statistics, pp. 1273–1282. PMLR, 2017b. J. Osborne. Improving your data transformations: Applying the Box-Cox transformation. Practical Assessment, Research, and Evaluation, 15(1):12, 2010. Mustafa Safa Ozdayi, Murat Kantarcioglu, and Yulia R Gel. Defending against backdoors in federated learning with robust learning rate. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 35, pp. 9268–9276, 2021. Krishna Pillutla, Sham M Kakade, and Zaid Harchaoui. Robust aggregation for federated learning. IEEE Transactions on Signal Processing, 70:1142–1154, 2022. Swaroop Ramaswamy, Rajiv Mathews, Kanishka Rao, and Franc¸oise Beaufays. Federated learning for emoji prediction in a mobile keyboard. arXiv preprint arXiv:1906.04329, 2019. M. Rosenblatt. A central limit theorem and a strong mixing condition. National Academy of Sciences, 42(1):43–47, 1956. R. M. Sakia. The Box-Cox transformation technique: A review. Journal of the Royal Statistical Society: Series D, 41(2):169–178, 1992. E. B. Sasson, A. Chiesa, C. Garman, M. Green, I. Miers, E. Tromer, and M. Virza. Zerocash: Decentralized anonymous payments from bitcoin. In IEEE S&P, 2014. Jingwei Sun, Ang Li, Louis DiValentin, Amin Hassanzadeh, Yiran Chen, and Hai Li. Fl-wbc: Enhancing robustness against model poisoning attacks in federated learning from a client perspective. Advances in Neural Information Processing Systems, 34:12613–12624, 2021. Ziteng Sun, Peter Kairouz, Ananda Theertha Suresh, and H Brendan McMahan. Can you really backdoor federated learning? arXiv preprint arXiv:1911.07963, 2019. Circom Contributors. Circom zkSNARK ecosystem, 2022. https://github.com/iden3/circom. Vale Tolpegin, Stacey Truex, Mehmet Emre Gursoy, and Ling Liu. Data poisoning attacks against federated learning systems. In European Symposium on Research in Computer Security, pp. 480– 501. Springer, 2020. Richard Tomsett, Kevin Chan, and Supriyo Chakraborty. Model poisoning attacks against distributed machine learning systems. In Artificial Intelligence and Machine Learning for Multi-Domain Operations Applications, volume 11006, pp. 481–489. SPIE, 2019. H. Wang, K. Sreenivasan, S. Rajput, H. Vishwakarma, S. Agarwal, J. Sohn, K. Lee, and D. Papailiopoulos. Attack of the tails: Yes, you really can backdoor federated learning. In NeurIPS, 2020. Jianhua Wang. Pass: Parameters audit-based secure and fair federated learning scheme against free rider. arXiv preprint arXiv:2207.07292, 2022. S. Weisberg. Yeo-Johnson power transformations. 2001. Available at https://www.stat.umn.edu/arc/yjpower.pdf. Cong Xie, Oluwasanmi Koyejo, and Indranil Gupta. SLSGD: Secure and Efficient Distributed Ondevice Machine Learning. In Joint European Conference on Machine Learning and Knowledge Discovery in Databases, pp. 213–228. Springer, 2020. H. Yang, X. Zhang, M. Fang, and J. Liu. Byzantine-resilient stochastic gradient descent for distributed learning: A Lipschitz-inspired coordinate-wise median approach. In IEEE CDC, 2019. Dong Yin, Yudong Chen, Kannan Ramchandran, and Peter Bartlett. Byzantine-robust distributed learning: Towards optimal statistical rates. In International Conference on Machine Learning, pp. 5650–5659. PMLR, 2018. Zaixi Zhang, Xiaoyu Cao, Jinyuan Jia, and Neil Zhenqiang Gong. Implementation of fldetector. https://github.com/zaixizhang/FLDetector, 2022a. Zaixi Zhang, Xiaoyu Cao, Jinyuan Jia, and Neil Zhenqiang Gong. Fldetector: Defending federated learning against model poisoning attacks via detecting malicious clients. In Proceedings of the 28th ACM SIGKDD Conference on Knowledge Discovery and Data Mining, pp. 2545–2555, 2022b. Zhengming Zhang, Ashwinee Panda, Linyue Song, Yaoqing Yang, Michael W. Mahoney, Joseph Gonzalez, Kannan Ramchandran, and Prateek Mittal. Neurotoxin: Durable backdoors in federated learning. In International Conference on Machine Learning, 2022c. URL https: //api.semanticscholar.org/CorpusID:249889464. A APPENDIX A.1 PROOF OF THE RANGE OF PPV B ZKP IMPLEMENTATION B.1 CHOICE OF THE ZKP SYSTEM In our implementation, we use the Groth16 (Groth, 2016) zkSNARK scheme implemented in the Circom library (Circom Contributors, 2022) for all the computations described above. We chose this ZKP scheme because its construction ensures constant proof size (128 bytes) and constant verification time. Because of this, Groth16 is popular for blockchain application due to small on-chain computation. There are other ZKP schemes based on different construction that can achieve faster prover time (Liu et al., 2021), but the proof size is too big and verification time is not constant, which is a problem if verifier lacks computational power. The construction of a ZKP scheme that is efficient for both prover and verifier is still an open research direction. B.2 SUPPLEMENTARY EXPERIMENTS FOR IMPORTANCE LAYER

Zero-Knowledge-Proof-Based Anomaly Detection: Conclusion & References

This paper is available on arxiv under CC BY-NC-SA 4.0 DEED license. Authors: (1) Shanshan Han & Qifan Zhang, UCI; (2) Wenxuan Wu, Texas A&M University; (3) Baturalp Buyukates, Yuhang Yao & Weizhao Jin, USC; (4) Salman Avestimehr, USC & FedML. Table of Links Abstract and Introduction Problem Setting The Proposed Two-Stages Anomaly Detection Verifiable Anomaly Detection using ZKP Evaluations Related Works Conclusion & References ABSTRACT Federated learning (FL) systems are vulnerable to malicious clients that submit poisoned local models to achieve their adversarial goals, such as preventing the convergence of the global model or inducing the global model to misclassify some data. Many existing defense mechanisms are impractical in real-world FL systems, as they require prior knowledge of the number of malicious clients or rely on re-weighting or modifying submissions. This is because adversaries typically do not announce their intentions before attacking, and re-weighting might change aggregation results even in the absence of attacks. To address these challenges in real FL systems, this paper introduces a cutting-edge anomaly detection approach with the following features: i) Detecting the occurrence of attacks and performing defense operations only when attacks happen; ii) Upon the occurrence of an attack, further detecting the malicious client models and eliminating them without harming the benign ones; iii) Ensuring honest execution of defense mechanisms at the server by leveraging a zero-knowledge proof mechanism. We validate the superior performance of the proposed approach with extensive experiments. 1 INTRODUCTION Federated Learning (FL) (McMahan et al., 2017a) enables clients to collaboratively train machine learning models without sharing their local data with other parties, maintaining the privacy and security of their local data. Due to its privacy-preserving nature, FL has attracted considerable attention across various domains and has been utilized in numerous areas (Hard et al., 2018; Chen et al., 2019; Ramaswamy et al., 2019; Leroy et al., 2019; Byrd & Polychroniadou, 2020; Chowdhury et al., 2022). However, even though FL does not require sharing raw data with others, its decentralized and collaborative nature inadvertently introduces privacy and security vulnerabilities (Cao & Gong, 2022; Bhagoji et al., 2019; Lam et al., 2021; Jin et al., 2021; Tomsett et al., 2019; Chen et al., 2017; Tolpegin et al., 2020; Kariyappa et al., 2022; Zhang et al., 2022c). Malicious clients in FL systems can harm training by submitting spurious models to disrupt the global model from converging (Fang et al., 2020; Chen et al., 2017), or planting backdoors to induce the global model to perform wrongly for certain samples (Bagdasaryan et al., 2020b;a; Wang et al., 2020). Existing literature on robust learning and mitigation of adversarial behaviors includes Blanchard et al. (2017); Yang et al. (2019); Fung et al. (2020); Pillutla et al. (2022); He et al. (2022); Cao et al. (2022); Karimireddy et al. (2020); Sun et al. (2019); Fu et al. (2019); Ozdayi et al. (2021); Sun et al. (2021), etc. These approaches exhibit shortcomings, making them less suitable for real FL systems. Some of these strategies require prior knowledge about the number of malicious clients within the FL system (Blanchard et al., 2017), even though in practice an adversary would not notify the system before attacking. Also, some of these methods mitigate impacts of potential malicious client submissions by re-weighting the local models (Fung et al., 2020), retaining only several local models that are most likely to be benign while removing others (Blanchard et al., 2017), or modifying the aggregation function (Pillutla et al., 2022). These methods have the potential to unintentionally alter the aggregation results in the absence of deliberate attacks, considering attacks happen infrequently in real-world scenarios. While the defense mechanisms can mitigate the impact of potential attacks, they can inadvertently compromise the result quality when applied to benign cases. Moreover, existing defense mechanisms are deployed at the FL server without any verification procedures to ensure their correct execution. While most of the clients are benign and wish to collaboratively train machine learning models, they can also be skeptic about the server’s reliability due to the execution of the defense mechanisms that modify the original aggregation procedure. Thus, a successful anomaly detection approach should simultaneously satisfy the following: i) It should be able to detect the occurrence of attacks and exclusively handle the cases when attacks happen. ii) If an attack is detected, the strategy must further detect malicious client submissions and accordingly mitigate (or eliminate) their adversarial impacts without harming the benign client models. iii) There should be a robust mechanism to corroborate the honest execution of defense mechanisms. In this work, we propose a novel anomaly detection mechanism that is specifically tailored to address genuine challenges faced by real-world FL systems. Our approach follows a two-stage scheme at the server to filter out malicious client submissions before aggregation. It initiates with a crossround check based on some cache called “reference models” to determine whether any attacks have occurred. In case of attacks, a subsequent cross-client detection is executed to eliminate malicious clients models without harming the benign client models. Meanwhile, the reference models in the cache is renewed. We provide an overview in Figure 1. Our contributions are summarized as follows: Our strategy is equipped with an initial cross-round check to detect the occurrence of potential attacks, ensuring that defensive methods are only activated in response to the presence of attacks, thereby maintaining the sanctity of the process in attack-free scenarios. ) Proactive attack detection. i By coupling the cross-round check with a subsequent crossclient detection, our approach efficiently eliminates malicious client submissions without harming the benign local submissions. ) Enhanced anomaly detection. ii Our method operates effectively without any prerequisites such as data distribution or the number of malicious clients. Such autonomous nature ensures widespread applicability and adaptability of our approach across different FL tasks, regardless of the data distribution and the selection of models. ) Autonomy from prior knowledge. iii Incorporating Zero-Knowledge Proof (ZKP) (Goldwasser et al., 1989) methodologies, our approach guarantees that the elimination of malicious client models is executed correctly, ensuring that clients can place trust in the defense mechanism in the FL system. ) Rigorous verification protocol. iv

A Zero-Knowledge Anomaly Detection Approach for Robust Federated Learning

শক্তিশালী ফেডারেটেড লার্নিংয়ের জন্য একটি শূন্য-জ্ঞান অসঙ্গতি সনাক্তকরণ পদ্ধতি

Ein wissensfreier Anomalieerkennungsansatz für robustes föderiertes Lernen

Un enfoque de detección de anomalías sin conocimiento para un aprendizaje federado sólido

Une approche de détection des anomalies sans connaissance pour un apprentissage fédéré robuste

मजबूत फ़ेडरेटेड लर्निंग के लिए एक शून्य-ज्ञान विसंगति का पता लगाने का दृष्टिकोण

堅牢なフェデレーテッド ラーニングのためのゼロ知識異常検出アプローチ

강력한 연합 학습을 위한 영지식 이상 탐지 접근 방식

Uma abordagem de detecção de anomalias de conhecimento zero para aprendizagem federada robusta

Подход к обнаружению аномалий с нулевым разглашением для надежного федеративного обучения

Güçlü Birleştirilmiş Öğrenme için Sıfır Bilgi Anormallik Tespiti Yaklaşımı

Phương pháp phát hiện bất thường không có kiến thức để học tập liên kết mạnh mẽ

用于鲁棒联邦学习的零知识异常检测方法

LEVRO

levro.com

-- employees

Since n.d.

COMPANY RANKING

LEVRO

EVERGREEN INDEX #6715

Representing this company? Click here to claim and customize this page!

Levro WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

LEVRO

levro.com

-- employees

Since n.d.

COMPANY RANKING

LEVRO

EVERGREEN INDEX #6715

RELATED COMPANIESRANK

STORIES ABOUT LEVRO

Representing this company? Click here to claim and customize this page!

Levro WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!