We consider the fully dynamic bin packing problem, where items arrive and depart in an online fashion and repacking of previously packed items is allowed. The goal is, of course, to minimize both the number of bins used as well as the amount of repacking. A recently introduced way of measuring the repacking costs at each timestep is the migration factor, defined as the total size of repacked items divided by the size of an arriving or departing item. Concerning the trade-off between number of bins and migration factor, if we wish to achieve an asymptotic competitive ration of 1 + ǫ for the number of bins, a relatively simple argument proves a lower bound of Ω( 1 /ǫ) for the migration factor. We establish a nearly matching upper bound of O( 1 /ǫ 4 log 1 /ǫ) using a new dynamic rounding technique and new ideas to handle small items in a dynamic setting such that no amortization is needed. The running time of our algorithm is polynomial in the number of items n and in 1 /ǫ. The previous best trade-off was for an asymptotic competitive ratio of 5 /4 for the bins (rather than 1 + ǫ) and needed an amortized number of O(log n) repackings (while in our scheme the number of repackings is independent of n and non-amortized). * Supported by DFG Project, Entwicklung und Analyse von effizienten polynomiellen Approximationsschemata für Scheduling-und verwandte Optimierungsprobleme, Ja 612/14-1. Algorithm: Insertionif SIZE(I(t)) < (m + 2)( 1 /δ + 2) or SIZE(I(t)) < 8( 1 /δ + 1) then use offline Bin Packing else improve(2); insert(i); // Shifting to the correct interval Let J i be the interval containing ∆(t); Let J j be the interval containingRename (A, B); improve(1); shiftA;Algorithm: Deletion if SIZE(I(t)) < (m + 2)( 1 /δ + 2) or SIZE(I(t)) < 8( 1 /δ + 1) then use offline Bin Packing else // Departing item i improve(4); delete(i); ReduceComponents; // // Shifting to the correct interval Let J i be the interval containing ∆(t); Let J j be the interval containingA(t)+B(t) ; Set d = i − j; if k(t) < k(t − 1) then // Modulo A(t) + B(t) when k decreases d = d -(A(t)+B(t)); // Shifting d groups from A to B for p := 0 to |d| − 1 do if i-p = 0 then Rename(A,B); improve(3); shiftB;

Parameterized complexity theory has lead to a wide range of algorithmic breakthroughs within the last decades, but the practicability of these methods for real-world problems is still not well understood. We investigate the practicability of one of the fundamental approaches of this field: dynamic programming on tree decompositions. Indisputably, this is a key technique in parameterized algorithms and modern algorithm design. Despite the enormous impact of this approach in theory, it still has very little influence on practical implementations. The reasons for this phenomenon are manifold. One of them is the simple fact that such an implementation requires a long chain of non-trivial tasks (as computing the decomposition, preparing it,. . . ). We provide an easy way to implement such dynamic programs that only requires the definition of the update rules. With this interface, dynamic programs for various problems, such as 3-coloring, can be implemented easily in about 100 lines of structured Java code.The theoretical foundation of the success of dynamic programming on tree decompositions is well understood due to Courcelle's celebrated theorem, which states that every MSO-definable problem can be efficiently solved if a tree decomposition of small width is given. We seek to provide practical access to this theorem as well, by presenting a lightweight model-checker for a small fragment of MSO. This fragment is powerful enough to describe many natural problems, and our model-checker turns out to be very competitive against similar state-of-the-art tools. ACM Subject Classification Theory of computation → Design and analysis of algorithmsBy combining this result (known as Courcelle's Theorem) with the f (tw(G)) · |G| algorithm of Bodlaender [7] to compute an optimal tree decomposition in fpt-time, a wide range of graph-theoretic problems is known to be solvable on these tree-like graphs. Unfortunately, both ingredients of this approach are very expensive in practice.One of the major achievements concerning practical parameterized algorithms was the discovery of a practically fast algorithm for treewidth due to Tamaki [19]. Concerning Courcelle's Theorem, there are currently two contenders concerning efficient implementations of it: D-Flat, an Answer Set Programming (ASP) solver for problems on tree decompositions [1]; and Sequoia, an MSO solver based on model checking games [17]. Both solvers allow to solve very general problems and the corresponding overhead might, thus, be large compared to a straightforward implementation of the dynamic programs for specific problems. Our ContributionsIn order to study the practicability of dynamic programs on tree decompositions, we expand our tree decomposition library Jdrasil with an easy to use interface for such programs: The user only needs to specify the update rules for the different kind of nodes within the tree decomposition. The remaining work -computing a suitable optimized tree decomposition and performing the actual run of the dynamic program -are done by Jdrasil. Th...

The goal of an algorithm substitution attack (ASA), also called a subversion attack (SA), is to replace an honest implementation of a cryptographic tool by a subverted one which allows to leak private information while generating output indistinguishable from the honest output. Bellare, Paterson, and Rogaway provided at CRYPTO '14 a formal security model to capture this kind of attacks and constructed practically implementable ASAs against a large class of symmetric encryption schemes. At CCS'15, Ateniese, Magri, and Venturi extended this model to allow the attackers to work in a fully-adaptive and continuous fashion and proposed subversion attacks against digital signature schemes. Both papers also showed the impossibility of ASAs in cases where the cryptographic tools are deterministic. Also at CCS'15, Bellare, Jaeger, and Kane strengthened the original model and proposed a universal ASA against sufficiently random encryption schemes. In this paper we analyze ASAs from the perspective of steganography -the well known concept of hiding the presence of secret messages in legal communications. While a close connection between ASAs and steganography is known, this lacks a rigorous treatment. We consider the common computational model for secret-key steganography and prove that successful ASAs correspond to secure stegosystems on certain channels and vice versa. This formal proof allows us to conclude that ASAs are stegosystems and to "rediscover" several results concerning ASAs known in the steganographic literature.

Residuality plays an essential role for learning finite automata. While residual deterministic and non-deterministic automata have been understood quite well, fundamental questions concerning alternating automata (AFA) remain open. Recently, Angluin, Eisenstat, and Fisman (2015) have initiated a systematic study of residual AFAs and proposed an algorithm called AL* – an extension of the popular L* algorithm – to learn AFAs. Based on computer experiments they have conjectured that AL* produces residual AFAs, but have not been able to give a proof. In this paper we disprove this conjecture by constructing a counterexample. As our main positive result we design an efficient learning algorithm, named AL** and give a proof that it outputs residual AFAs only. In addition, we investigate the succinctness of these different FA types in more detail.

No abstract