TY - CONF AB - Turn-based stochastic games (aka simple stochastic games) are two-player zero-sum games played on directed graphs with probabilistic transitions. The goal of player-max is to maximize the probability to reach a target state against the adversarial player-min. These games lie in NP ∩ coNP and are among the rare combinatorial problems that belong to this complexity class for which the existence of polynomial-time algorithm is a major open question. While randomized sub-exponential time algorithm exists, all known deterministic algorithms require exponential time in the worst-case. An important open question has been whether faster algorithms can be obtained parametrized by the treewidth of the game graph. Even deterministic sub-exponential time algorithm for constant treewidth turn-based stochastic games has remain elusive. In this work our main result is a deterministic algorithm to solve turn-based stochastic games that, given a game with n states, treewidth at most t, and the bit-complexity of the probabilistic transition function log D, has running time O ((tn2 log D)t log n). In particular, our algorithm is quasi-polynomial time for games with constant or poly-logarithmic treewidth. AU - Chatterjee, Krishnendu AU - Meggendorfer, Tobias AU - Saona Urmeneta, Raimundo J AU - Svoboda, Jakub ID - 12676 SN - 9781611977554 T2 - Proceedings of the 2023 Annual ACM-SIAM Symposium on Discrete Algorithms TI - Faster algorithm for turn-based stochastic games with bounded treewidth ER - TY - CHAP AB - Here we describe the in vivo DNA assembly approach, where molecular cloning procedures are performed using an E. coli recA-independent recombination pathway, which assembles linear fragments of DNA with short homologous termini. This pathway is present in all standard laboratory E. coli strains and, by bypassing the need for in vitro DNA assembly, allows simplified molecular cloning to be performed without the plasmid instability issues associated with specialized recombination-cloning bacterial strains. The methodology requires specific primer design and can perform all standard plasmid modifications (insertions, deletions, mutagenesis, and sub-cloning) in a rapid, simple, and cost-efficient manner, as it does not require commercial kits or specialized bacterial strains. Additionally, this approach can be used to perform complex procedures such as multiple modifications to a plasmid, as up to 6 linear fragments can be assembled in vivo by this recombination pathway. Procedures generally require less than 3 h, involving PCR amplification, DpnI digestion of template DNA, and transformation, upon which circular plasmids are assembled. In this chapter we describe the requirements, procedure, and potential pitfalls when using this technique, as well as protocol variations to overcome the most common issues. AU - Arroyo-Urea, Sandra AU - Watson, Jake AU - García-Nafría, Javier ED - Scarlett, Garry ID - 12720 SN - 1064-3745 T2 - DNA Manipulation and Analysis TI - Molecular Cloning Using In Vivo DNA Assembly VL - 2633 ER - TY - CONF AB - Asynchronous programming has gained significant popularity over the last decade: support for this programming pattern is available in many popular languages via libraries and native language implementations, typically in the form of coroutines or the async/await construct. Instead of programming via shared memory, this concept assumes implicit synchronization through message passing. The key data structure enabling such communication is the rendezvous channel. Roughly, a rendezvous channel is a blocking queue of size zero, so both send(e) and receive() operations wait for each other, performing a rendezvous when they meet. To optimize the message passing pattern, channels are usually equipped with a fixed-size buffer, so sends do not suspend and put elements into the buffer until its capacity is exceeded. This primitive is known as a buffered channel. This paper presents a fast and scalable algorithm for both rendezvous and buffered channels. Similarly to modern queues, our solution is based on an infinite array with two positional counters for send(e) and receive() operations, leveraging the unconditional Fetch-And-Add instruction to update them. Yet, the algorithm requires non-trivial modifications of this classic pattern, in order to support the full channel semantics, such as buffering and cancellation of waiting requests. We compare the performance of our solution to that of the Kotlin implementation, as well as against other academic proposals, showing up to 9.8× speedup. To showcase its expressiveness and performance, we also integrated the proposed algorithm into the standard Kotlin Coroutines library, replacing the previous channel implementations. AU - Koval, Nikita AU - Alistarh, Dan-Adrian AU - Elizarov, Roman ID - 12735 SN - 9798400700156 T2 - Proceedings of the ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming TI - Fast and scalable channels in Kotlin Coroutines ER - TY - GEN AB - Although a wide variety of handcrafted concurrent data structures have been proposed, there is considerable interest in universal approaches (Universal Constructions or UCs) for building concurrent data structures. UCs (semi-)automatically convert a sequential data structure into a concurrent one. The simplest approach uses locks [3, 6] that protect a sequential data structure and allow only one process to access it at a time. However, the resulting data structure is blocking. Most work on UCs instead focuses on obtaining non-blocking progress guarantees such as obstruction-freedom, lock-freedom or wait-freedom. Many non-blocking UCs have appeared. Key examples include the seminal wait-free UC [2] by Herlihy, a NUMA-aware UC [10] by Yi et al., and an efficient UC for large objects [1] by Fatourou et al. AU - Aksenov, Vitaly AU - Brown, Trevor A AU - Fedorov, Alexander AU - Kokorin, Ilya ID - 12736 SN - 9798400700156 T2 - Proceedings of the ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming TI - Unexpected scaling in path copying trees ER - TY - CONF AB - Dynamic programming (DP) is one of the fundamental paradigms in algorithm design. However, many DP algorithms have to fill in large DP tables, represented by two-dimensional arrays, which causes at least quadratic running times and space usages. This has led to the development of improved algorithms for special cases when the DPs satisfy additional properties like, e.g., the Monge property or total monotonicity. In this paper, we consider a new condition which assumes (among some other technical assumptions) that the rows of the DP table are monotone. Under this assumption, we introduce a novel data structure for computing (1 + ϵ)-approximate DP solutions in near-linear time and space in the static setting, and with polylogarithmic update times when the DP entries change dynamically. To the best of our knowledge, our new condition is incomparable to previous conditions and is the first which allows to derive dynamic algorithms based on existing DPs. Instead of using two-dimensional arrays to store the DP tables, we store the rows of the DP tables using monotone piecewise constant functions. This allows us to store length-n DP table rows with entries in [0, W] using only polylog(n, W) bits, and to perform operations, such as (min, +)-convolution or rounding, on these functions in polylogarithmic time. We further present several applications of our data structure. For bicriteria versions of k-balanced graph partitioning and simultaneous source location, we obtain the first dynamic algorithms with subpolynomial update times, as well as the first static algorithms using only near-linear time and space. Additionally, we obtain the currently fastest algorithm for fully dynamic knapsack. AU - Henzinger, Monika H AU - Neumann, Stefan AU - Räcke, Harald AU - Schmid, Stefan ID - 12760 SN - 1868-8969 T2 - 40th International Symposium on Theoretical Aspects of Computer Science TI - Dynamic maintenance of monotone dynamic programs and applications VL - 254 ER -