Search

• Eulerian trails are classical and important objects in theoretical computer science field. • Enumeration of Eulerian trails is known to be #P-complete. • Although the existence of an algorithm with linear time per output is known, the existence of a faster algorithm is open. • This paper shows optimal algorithms for Eulerian trails which run in constant time per solution on average. In this paper, we consider enumeration problems for edge-distinct and vertex-distinct Eulerian trails. Two Eulerian trails are said to be edge-distinct if the edge sequences are not identical, and they are said to be vertex-distinct if the vertex sequences are not identical. To solve these problems, we propose optimal enumeration algorithms that run in O (N + m) total time, where N is the number of solutions and m is the number of edges in an input connected graph. The proposed algorithms are based on the reverse search technique introduced by [Avis and Fukuda, DAM 1996], and the push-out amortization technique introduced by [Uno, WADS 2015]. [ABSTRACT FROM AUTHOR]

Solid codes provide outstanding fault-tolerance when used for information transmission through a noisy channel involving not only symbol substitutions, but also synchronisation errors and black-outs. In this paper we provide an automaton theoretic characterisation of solid codes which takes this fault-tolerance into account. The fault-tolerance afforded by a solid code L can be summarised as follows: Consider messages, encoded using L , being sent through a noisy channel. Any code words in L , which are present in the received message, will be decoded correctly, unless they themselves happen to be the results of errors. Thus, errors in the received message will not lead to incorrect decodings of those parts which are error-free. In this paper we consider acceptors which are fault-tolerant in this sense when analysing such received messages. These acceptors characterise the class of solid codes. For finite solid codes an automaton characterisation was published in the sixties by Levenshtein and Romanov. The characterisation uses state-invariant finite-state transducers which act as decoders in such a way that an output is generated exactly when a code word has been read completely. State-invariance means that acceptance does not depend on the initial state — every state can be used as the initial state. The results of Levenshtein and Romanov depend strongly on the fact that the code is finite. In this paper we provide a general automaton theoretic characterisation of arbitrary solid codes without any such restriction. Moreover, the solid code is regular as a language if and only if the automaton used in the characterisation can be reduced to an equivalent finite automaton with equivalent properties. The main results of this paper are as follows: Every acceptor defines a solid code. For every solid code there is a fault-tolerant acceptor defining the code. Such acceptors expose the decomposition of potentially faulty received messages according to the code. For solid codes which are regular as languages these acceptors can be chosen to be finite while preserving all important combinatorial properties. Part of this work was presented at the 14th Journées Montoises of Theoretical Computer Science [32]. [ABSTRACT FROM AUTHOR]

Boolean functions have important applications in information technology and computer science. Certificate complexity is an important combinatorial measure of Boolean function complexity. In this paper, we first introduce many concise and efficient notations then we study the elementary symmetric Boolean functions and obtain their certificate complexities when their degrees are odd or powers of 2. We show that both upper and lower bounds of certificate complexities can be attained. [ABSTRACT FROM AUTHOR]

String matching is one of the most extensively studied problems in computer science, mainly due to its direct applications to such diverse areas as text, image and signal processing, speech analysis and recognition, information retrieval, data compression, computational biology and chemistry. In the last few decades a myriad of alternative solutions have been proposed, based on very different techniques. However, automata have always played a very important role in the design of efficient string matching algorithms. In this paper we present the Range Automaton , a weak yet efficient variant of the non-deterministic suffix automaton of a string whose configuration can be encoded in a very simple form and which is particularly suitable to be used for solving a multitude of text-searching problems. We will firstly develop our approach in the case of exact string matching and present an efficient algorithm, named Backward Range Automaton Matcher, which turns out to be very fast in many practical cases. Later, we will show how the Range Automaton can be adapted in an effective way also to non-standard string matching problems such as swap matching and multiple string matching. Experimental results suggest that our approach is flexible and effective for all three search problems addressed, especially in the case of long patterns. • We present a simple and efficient technique for simulating the suffix automaton of a string. • The new technique leads to the definition of an automaton, called Range Automaton, for the weak recognition of the suffixes of a string. • We apply the Range Automaton to the exact string matching problem, obtaining an efficient and flexible solution in practice, especially in the case of long patterns. • We extend the application of the Range Automaton to the swap matching problem, a special case of approximate string matching. • We extend the application of the Range Automaton to the problem of multiple pattern matching. [ABSTRACT FROM AUTHOR]

The problem of reducing ϵ -NN to (c , r) -NN is very important in theoretical computer science area and has attracted many research efforts. In this paper a new algorithm for such problem is proposed, which achieves O (log ⁡ n) query time. Comparing with the former algorithms for the same problem, this query time is the lowest, which is the main contribution of this paper. The low query time complexity is achieved by raising the preprocessing time and space complexity. How to reduce the cost added into the two complexities is also discussed in this paper. [ABSTRACT FROM AUTHOR]

Fair division of indivisible resources is a fundamental problem in many disciplines, including computer science, economy, operations research, etc. The existence of PMMS allocations of goods is a major open problem in fair division, even for additive valuations. At the state of the art, there is no identified setting where PMMS allocations are deemed impossible, and the known existing results regarding their existence are limited to highly constrained settings. In this paper, we provide an algorithm for computing a PMMS allocation for identical variant. We also use the algorithm to find the PMMS allocations for 3 agents in line graphs. Moreover, we show that a 4 5 -PMMS allocation can be computed in polynomial time when agents agree on the ordinal ranking of the goods. A quantitative gauge for assessing the impact on social welfare is known as the price of fairness , which quantifies the maximum possible reduction in social welfare due to the imposition of fairness constraints. Originally explored in the context of divisible goods, the concept of the price of fairness continues to be a pivotal metric for evaluating the effect of fairness considerations on overall social welfare. Consequently, we study the efficiency decrease under PMMS allocations and prove a tight upper bound on the price of PMMS allocations. • We present an algorithm to compute a PMMS allocation if agents' valuation functions are identical. • We analyze an existing algorithm terminates with a 4 5 -PMMS allocation in polynomial time when agents have identical ordinal ranking values of the goods. • We also examine the efficiency loss associated with PMMS allocations and establish their precise price bound. [ABSTRACT FROM AUTHOR]

• We consider a variant of the online buffer management problem. • This variant is called the 2-bounded delay buffer management problem with lookahead. • We design an optimal online algorithm for this variant. The bounded delay buffer management problem, which was proposed by Kesselman et al. (STOC 2001 and SIAM Journal on Computing 33(3), 2004), is an online problem focusing on buffer management of a switch supporting Quality of Service (QoS). The problem definition is as follows: Packets arrive to a buffer over time and each packet is specified by the release time , deadline and value. An algorithm can transmit at most one packet from the buffer at each integer time and can gain its value as the profit if transmitting the packet by its deadline after its release time. The objective of this problem is to maximize the gained profit. We say that an instance of the problem is s -bounded if for any packet, an algorithm has at most s chances to transmit it. For any s ≥ 2 , Hajek (CISS 2001) showed that the competitive ratio of any deterministic algorithm is at least (1 + 5) / 2 ≥ 1.618. Recently, Veselý et al. (SODA 2019) designed an online algorithm matching the lower bound. Böhm et al. (ISAAC 2016 and Theoretical Computer Science, 2019) introduced the lookahead ability to an online algorithm. At a time t , the algorithm obtains information about packets arriving at time t + 1 , and showed that for s = 2 , there is an algorithm which achieves the competitive ratio of (− 1 + 13) / 2 ≤ 1.303. Also, they showed that the competitive ratio of any deterministic algorithm is at least (1 + 17) / 4 ≥ 1.280. In this paper, for the 2-bounded model with lookahead, we design an algorithm with a matching competitive ratio of (1 + 17) / 4. [ABSTRACT FROM AUTHOR]

• Generalising confluence to confluence up to garbage. • Critical pair analysis for confluence up to garbage. • Back-tracking free recognition of graph languages. The transformation of graphs and graph-like structures is ubiquitous in computer science. When a system is described by graph-transformation rules, it is often desirable that the rules are both terminating and confluent so that rule applications in an arbitrary order produce unique resulting graphs. However, there are application scenarios where the rules are not globally confluent but confluent on a subclass of graphs that are of interest. In other words, non-resolvable conflicts can only occur on graphs that are considered as "garbage". In this paper, we introduce the notion of confluence up to garbage and generalise Plump's critical pair lemma for double-pushout graph transformation, providing a sufficient condition for confluence up to garbage by non-garbage critical pair analysis. We apply our results in two case studies about efficient language recognition: we present backtracking-free graph reduction systems which recognise a class of flow diagrams and a class of labelled series-parallel graphs, respectively. Both systems are non-confluent but confluent up to garbage. We also give a critical pair condition for subcommutativity up to garbage which, together with closedness, implies confluence up to garbage even in non-terminating systems. [ABSTRACT FROM AUTHOR]

• Study the minsum k -sink problems on dynamic flow path networks for the confluent/non-confluent flow model. • Develop algorithms which run in almost linear time regardless of the number of sinks k. • Improve upon the previous results for the same problem with the confluent flow model. • Provide the first polynomial time algorithm for the problem with the non-confluent flow model. • The main theoretical contribution is to construct novel data structures for solving subproblems in polylogarithmic time. We address the facility location problems on dynamic flow path networks. A dynamic flow path network consists of an undirected path with positive edge lengths, positive edge capacities, and positive vertex weights. A path can be considered as a road, an edge length as the distance along the road and a vertex weight as the number of people at the site. An edge capacity limits the number of people that can enter the edge per unit time. In the dynamic flow network, given particular points on edges or vertices, called sinks , all the people evacuate from the vertices to the sinks as quickly as possible. The problem is to find the location of sinks on a dynamic flow path network in such a way that the aggregate evacuation time (i.e., the sum of evacuation times for all the people) to sinks is minimized. We consider two models of the problem: the confluent flow model and the non-confluent flow model. In the former model, the way of evacuation is restricted so that all the people at a vertex have to evacuate to the same sink, and in the latter model, there is no such restriction. In this paper, for both the models, we develop algorithms which run in almost linear time regardless of the number of sinks. It should be stressed that for the confluent flow model, our algorithm improves upon the previous result by Benkoczi et al. [Theoretical Computer Science, 2020], and one for the non-confluent flow model is the first polynomial time algorithm. [ABSTRACT FROM AUTHOR]

Suppose that two independent sets I b and I r of a graph such that | I b | = | I r | are given, and a token is placed on each vertex in I b. The sliding token problem is to determine whether there exists a sequence of independent sets which transforms I b into I r so that each independent set in the sequence results from the previous one by sliding exactly one token along an edge in the graph. The sliding token problem is one of the reconfiguration problems that attract the attention from the viewpoint of theoretical computer science. Recently, the problems that aim at finding a shortest reconfiguration sequence are investigated. In general, even if it is polynomial time solvable to decide whether two instances are reconfigurable into each other, it can be NP-hard to find a shortest sequence between them. In this paper, we show that the problem for finding a shortest sequence between two independent sets is polynomial time solvable for some graph classes which are subclasses of the class of interval graphs. As far as the authors know, this is the first polynomial time algorithm for the shortest sliding token problem for a graph class that requires detours. [ABSTRACT FROM AUTHOR]

The lambda calculus can be seen as a language that connects mathematics with computer science. However, the models used in both disciplines have different basic properties. In computer science these models are mainly based on domain theory with its partial functions and its fixed point property. In mathematics the models use total functions and relations and allow the integration of logic. Typically, mathematical models are based on set theory with its actual infinite sets, which are incongruous with computer science. We will present a dynamic model that is based consequently on the potential infinite. It uses total functions, whereby functions and the function spaces are seen as interdependent, increasing finite entities. It moreover allows the integration of higher-order logic (to be demonstrated in a separate paper), provided the universal quantifier is interpreted in a specific, dynamic way. Such a model can serve as a common denotational semantics of the lambda calculus for both, mathematics and computer science. • The paper presents a mathematical formulation of a potential infinite set, called factor system. • Factor systems are closed under the function space construction, so they are potential infinite models of simple type theory. • Each factor system has a limit whose elements can be characterized as maximal, consistent sets of states. • Models based on factor systems allow the integration of higher-order logic. The presentation of this is a future task. [ABSTRACT FROM AUTHOR]

This paper is about two generalizations of the mistake bound model to online multiclass classification. In the standard model , the learner receives the correct classification at the end of each round, and in the bandit model , the learner only finds out whether its prediction was correct or not. For a set F of multiclass classifiers, let opt std (F) and opt bandit (F) be the optimal bounds for learning F according to these two models. We show that an opt bandit (F) ≤ (1 + o (1)) (| Y | ln ⁡ | Y |) opt std (F) bound is the best possible up to the leading constant, closing a Θ (log ⁡ | Y |) factor gap. [ABSTRACT FROM AUTHOR]

Pattern languages have been an object of study in various subfields of computer science for decades. This paper introduces and studies a decision problem on patterns called the finite distinguishability problem: given a pattern π , are there finite sets T + and T − of strings such that the only pattern language containing all strings in T + and none of the strings in T − is the language generated by π ? This problem is related to the complexity of teacher-directed learning, as studied in computational learning theory, as well as to the long-standing open question whether the equivalence of two patterns is decidable. We show that finite distinguishability is decidable if the underlying alphabet is of size other than 2 or 3, and provide a number of related results, such as (i) partial solutions for alphabet sizes 2 and 3, and (ii) decidability proofs for variants of the problem for special subclasses of patterns, namely, regular, 1-variable, and non-cross patterns. For the same subclasses, we further determine the values of two complexity parameters in teacher-directed learning, namely the teaching dimension and the recursive teaching dimension. [ABSTRACT FROM AUTHOR]

Combinatorial problems are a fundamental research subject of theoretical computer science, and for a general graph many combinatorial problems are NP-hard and even #P-complete. Thus, it is interesting to seek or design special graphs for which these difficult combinatorial problems can be exactly solved. In this paper, we study some combinatorial problems for the Farey graphs, which are translated from Farey sequences and have received considerable attention from the scientific community. We determine exactly the domination number, the independence number, and the matching number. Moreover, we derive exact or recursive solutions to the number of minimum dominating sets, the number of dominating sets, the number of maximum independent sets, the number of independent sets, the number of maximum matchings, as well as the number of matchings. Finally, we obtain explicit expressions for the number of acyclic orientations and the number of root-connected acyclic orientations. Since the considered combinatorial problems have found wide applications in diverse fields, such as network science and graph data miming, this work is helpful for deepening our understanding of the applications for these combinatorial problems. [ABSTRACT FROM AUTHOR]

• The minimum cycle cover problem. • A simplified approach of analysis. • An O (n 2) time 24/5-approximation algorithm. • A new O (n 3) time 14/3-approximation algorithm. • An improved O (n 5) time 32/7-approximation algorithm. Given an undirected weighted graph G = (V , E) with nonnegative weight function obeying the triangle inequality, a set { C 1 , C 2 , ... , C k } of cycles is called a cycle cover if V ⊆ ⋃ i = 1 k V (C i) and its cost is given by the maximum weight of the cycles. The Minimum Cycle Cover Problem aims to find a cycle cover of cost at most λ with the minimum number of cycles. An O (n 2) 24/5-approximation algorithm and an O (n 5) 14/3-approximation algorithm are given by Yu and Liu (Improved approximation algorithms for some min-max cycle cover problems. Theoretical Computer Science 654 (2016) 45–58). However, the original proofs for approximation ratios are incomplete. In this paper we first present a corrected simplified analysis on the 24/5-approximation algorithm. Based on the simplified approach of analysis and some new observations, we present a new 14/3-approximation algorithm that runs in O (n 3) and give an improved 32/7-approximation algorithm that runs in O (n 5). [ABSTRACT FROM AUTHOR]

Boolean nested canalizing functions (NCF) have important applications in molecular regulatory networks, engineering and computer science. In the literature, there are two sensitivities to measure the complexity of a Boolean function. One is average sensitivity, the other one is maximal sensitivity. We follow the tradition and omit the word "maximal". In other words, in this paper, sensitivity is always maximal sensitivity. Using the past work of the authors and their coauthors on a characterization of NCF, we obtain the formula of the sensitivity of any NCF. We find that the sensitivity of any NCF is between ⌈ n + 2 2 ⌉ and n. Both lower and upper bounds are tight. We prove that the block sensitivity, hence the l -block sensitivity, is the same as the sensitivity for NCF. It is well known that monotone Boolean functions (MBF) also have this property. We characterize all functions which are both monotone and nested canalizing (MNCF). The closed formula of the cardinality of the set of MNCFs is also provided. • The closed formula of the maximal sensitivity of Boolean nested canalizing functions is obtained. • Both the lower and upper tight bounds of the maximal sensitivity of Boolean nested canalizing functions are computed. • The maximal sensitivity and the block sensitivity of nested canalizing functions are equal. • The algebraic normal forms of monotone nested canalizing functions are provided. • The closed formula of the number of monotone nested canalizing functions is obtained. [ABSTRACT FROM AUTHOR]

Graph tries are a new and interesting data structure proposed by Jacquet in 2014. They generalize the classical trie data structure which has found many applications in computer science and is one of the most popular data structure on words. For his generalization, Jacquet considered the size (or space requirement) and derived an asymptotic expansion for the mean and the variance when graph tries are built from n independently chosen random labelings of a rooted M -ary tree. Moreover, he conjectured a central limit theorem for the (suitably normalized) size as the number of labelings tends to infinity. In this paper, we verify this conjecture with the method of moments. [ABSTRACT FROM AUTHOR]

Abstract In this paper we study the approximation ratio of the solutions achieved after an ϵ -approximate one-round walk in non-atomic congestion games. Prior to this work, the solution concept of one-round walks had been studied for atomic congestion games with linear latency functions only (Christodoulou et al. [1] , Bilò et al. [2]). We give an explicit formula to determine the approximation ratio for non-atomic congestion games having general latency functions. In particular, we focus on polynomial latency functions, and, we prove that the approximation ratio is exactly ((1 + ϵ) (p + 1)) p + 1 for every polynomial of degree p. Then, we show that, by resorting to static (resp. dynamic) resource taxation, the approximation ratio can be lowered to (1 + ϵ) p + 1 (p + 1) p (resp. (1 + ϵ) p + 1 (p + 1) !). [ABSTRACT FROM AUTHOR]

Abstract Since the 80s, model checking (MC) has been applied to the automatic verification of hardware/software systems. Point-based temporal logics, such as LTL , CTL , CTL ⁎ , and the like, are commonly used in MC as the specification language; however, there are some inherently interval-based properties of computations, e.g., temporal aggregations and durations, that cannot be properly dealt with by these logics, as they model a state-by-state evolution of systems. Recently, an MC framework for the verification of interval-based properties of computations, based on Halpern and Shoham's interval temporal logic (HS , for short) and its fragments, has been proposed and systematically investigated. In this paper, we focus on the boundaries that separate tractable and intractable HS fragments in MC. We first prove that MC for the logic BE of Allen's relations started-by and finished-by is provably intractable, being Expspace -hard. Such a lower bound immediately propagates to full HS. Then, in contrast, we show that other noteworthy HS fragments, i.e., the logic A A ‾ B B ‾ (resp., A A ‾ E E ‾) of Allen's relations meets , met-by , starts (resp., finishes), and started-by (resp., finished-by), are well-behaved, and turn out to have the same complexity as LTL (Pspace -complete). Halfway are the fragments A A ‾ B B ‾ E ‾ and A A ‾ E B ‾ E ‾ , whose Expspace membership and Pspace hardness are already known. Here, we give an original proof of Expspace membership, that substantially simplifies the complexity of the constructions previously used for such a result. Contraction techniques—suitably tailored to each HS fragment—are at the heart of our results, enabling us to prove a pair of remarkable small-model properties. [ABSTRACT FROM AUTHOR]

Abstract This paper studies the well-known problem of gathering multiple mobile agents moving in a graph, but unlike previous results, we consider the problem in the presence of an adversarial mobile entity which we call the malicious agent. The malicious entity can occupy any empty node and prevent honest mobile agents from entering this node. This new adversarial model is interesting as it models transient mobile faults that can appear anywhere in a network. Moreover, our model lies between the less powerful delay-fault model , where the adversary can block an agent for only a finite time, and the more powerful but static fault model of black holes that can even destroy the agents. We study the problem for ring networks and we provide a complete characterization of the solvability of gathering, depending on the size n of the ring and the number of agents k. We consider both oriented or unoriented rings with either synchronous or asynchronous agents. We prove that in an unoriented ring network with asynchronous agents the problem is not solvable when k is even, while for synchronous agents the problem is unsolvable when both n is odd and k is even. We then present algorithms that solve gathering for all the remaining cases, thus completely solving the problem. Finally, we provide a proof-of-concept implementation of the synchronous algorithms using programmable Lego Mindstorms EV3 robots. [ABSTRACT FROM AUTHOR]

Abstract A locally connected spanning tree (LCST) T of a graph G is a spanning tree of G such that, for each node, its neighborhood in T induces a connected subgraph in G. The problem of determining whether a graph contains an LCST or not has been proved to be NP-complete, even if the graph is planar or chordal. The main result of this paper is a simple linear time algorithm that, given a maximal planar chordal graph, determines in linear time whether it contains an LCST or not, and produces one if it exists. We give an analogous result for the case when the input graph is a maximal outerplanar graph. [ABSTRACT FROM AUTHOR]

Compositional Game Theory is a new, recently introduced model of economic games based upon the computer science idea of compositionality. In it, complex and irregular games can be built up from smaller and simpler games, and the equilibria of these complex games can be defined recursively from the equilibria of their simpler subgames. This paper extends the model by providing a final coalgebra semantics for infinite games. In the course of this, we introduce a new operator on games to model the economic concept of subgame perfection. [ABSTRACT FROM AUTHOR]

In a recent paper (M. Barash, A. Okhotin, “An extension of context-free grammars with one-sided context specifications”, Inform. and Comput. , 2014), the authors introduced an extension of the context-free grammars equipped with an operator for referring to the left context of the substring being defined. This paper proposes a more general model, in which context specifications may be two-sided, that is, both the left and the right contexts can be specified by the corresponding operators. The paper gives the definitions, presents several examples of grammars and establishes a basic normal form theorem. This normal form, in particular, leads to a simple parsing algorithm working in time O ( n 4 ) , where n is the length of the input string. [ABSTRACT FROM AUTHOR]

Many problems in Computer Science can be abstracted to the following question: given a set of objects and rules respectively, which new objects can be produced? In the paper, we consider a succinct version of the question: given a set of binary strings and several operations like conjunction and disjunction , which new binary strings can be generated? Although it is a fundamental problem, to the best of our knowledge, the problem hasn't been studied yet. In this paper, an O ( m 2 n ) algorithm is presented to determine whether a string s is representable by a set W , where n is the number of strings in W and each string has the same length m . However, looking for the minimum subset to represent a given string is shown to be NP -hard. Also, finding the smallest subset to represent each string in the original set is NP -hard. We establish tight inapproximability results and approximation algorithms for these NP -hard problems. In addition, we prove that counting the number of representable strings is # P -complete. We then explore how the problems change when the operator negation is available. For example, if the operator negation can be used, the counting problem is as simple as some power of 2. This difference may help us to better understand the problem. [ABSTRACT FROM AUTHOR]

Finding heavy-elements (heavy-hitters) in streaming data is one of the central, and well-understood tasks. Despite the importance of this problem, when considering the sliding windows model of streaming (where elements eventually expire) the problem of finding L 2 -heavy elements has remained completely open despite multiple papers and considerable success in finding L 1 -heavy elements. Since the L 2 -heavy element problem doesn't satisfy certain conditions, existing methods for sliding windows algorithms, such as smooth histograms or exponential histograms are not directly applicable to it. In this paper, we develop the first polylogarithmic-memory algorithm for finding L 2 -heavy elements in the sliding window model. Our technique allows us not only to find L 2 -heavy elements, but also heavy elements with respect to any L p with 0 < p ≤ 2 on sliding windows. By this we completely “close the gap” and resolve the question of finding L p -heavy elements in the sliding window model with polylogarithmic memory, since it is well known that for p > 2 this task is impossible. We demonstrate a broader applicability of our method on two additional examples: we show how to obtain a sliding window approximation of the similarity of two streams, and of the fraction of elements that appear exactly a specified number of times within the window (the α -rarity problem). In these two illustrative examples of our method, we replace the current expected memory bounds with worst case bounds. [ABSTRACT FROM AUTHOR]

The problem of automated theorem finding is one of the 33 basic research problems in automated reasoning which was originally proposed by Wos in 1988, and it is still an open problem. To solve the problem, an approach of forward deduction based on the strong relevant logics was proposed. Following the approach, this paper presents a systematic methodology for automated theorem finding. To show the effectiveness of our methodology, the paper presents two case studies, one is automated theorem finding in NBG set theory and the other is automated theorem finding in Peano's arithmetic. Some known theorems have been found in our case studies. [ABSTRACT FROM AUTHOR]

In the Closest String problem we are given an alphabet Σ, a set of strings S = { s 1 , s 2 , … , s k } over Σ such that | s i | = n and an integer d . The objective is to check whether there exists a string s over Σ such that d H ( s , s i ) ≤ d , i ∈ { 1 , … , k } , where d H ( x , y ) denotes the number of places strings x and y differ at. Closest String is a prototype string problem. This problem together with several of its variants such as Distinguishing String Selection and Closest Substring have been extensively studied from parameterized complexity perspective. These problems have been studied with respect to parameters that are combinations of k , d , | Σ | and n . However, surprisingly the kernelization question for these problems (for the versions when they admit fixed-parameter tractable algorithms) is not studied at all. In this paper we fill this gap in the literature and do a comprehensive study of these problems from kernelization complexity perspective. We settle almost all the problems by either obtaining a polynomial kernel or showing that the problem does not admit a polynomial kernel under a standard assumption in complexity theory. [ABSTRACT FROM AUTHOR]

As a fundamental subject of theoretical computer science, the maximum independent set (MIS) problem not only is of purely theoretical interest, but also has found wide applications in various fields. However, for a general graph determining the size of a MIS is NP-hard, and exact computation of the number of all MISs is even more difficult. It is thus of significant interest to seek special graphs for which the MIS problem can be exactly solved. In this paper, we address the MIS problem in the pseudofractal scale-free web and the Sierpiński gasket, which have the same number of vertices and edges. For both graphs, we determine exactly the independence number and the number of all possible MISs. The independence number of the pseudofractal scale-free web is as twice as the one of the Sierpiński gasket. Moreover, the pseudofractal scale-free web has a unique MIS, while the number of MISs in the Sierpiński gasket grows exponentially with the number of vertices. [ABSTRACT FROM AUTHOR]

In the combinatorial study of words, the Parikh matrix mapping was introduced by Mateescu et al. in 2001 as a natural expansion of the classical Parikh mapping. Solving the general injectivity problem of Parikh matrices remains as one of the most sought after triumph among researchers in this area of study. In this paper, we tackle this problem by extending Şerbǎnuţǎ's work regarding prints and M -unambiguity to the context of strong M -equivalence. Consequently, we obtain results on the finiteness of strongly M -unambiguous prints for any finite alphabet. Finally, a related conjecture by Şerbǎnuţǎ is conclusively addressed. [ABSTRACT FROM AUTHOR]

Abstract: A breakthrough in the field of text algorithms was the discovery of the fact that the maximal number of runs in a word of length n is and that they can all be computed in time. We study some applications of this result. New simpler time algorithms are presented for classical textual problems: computing all distinct k-th word powers for a given k, in particular squares for , and finding all local periods in a given word of length n. Additionally, we present an efficient algorithm for testing primitivity of factors of a word and computing their primitive roots. Applications of runs, despite their importance, are underrepresented in existing literature (approximately one page in the paper of Kolpakov and Kucherov, 1999 [25,26]). In this paper we attempt to fill in this gap. We use Lyndon words and introduce the Lyndon structure of runs as a useful tool when computing powers. In problems related to periods we use some versions of the Manhattan skyline problem. [Copyright &y& Elsevier]

Abstract: This paper studies the deviations of the regret in a stochastic multi-armed bandit problem. When the total number of plays n is known beforehand by the agent, Audibert et al. [2] exhibit a policy such that with probability at least , the regret of the policy is of order log n. They have also shown that such a property is not shared by the popular ucb1 policy of Auer et al. [3]. This work first answers an open question: it extends this negative result to any anytime policy (i.e. any policy that does not take the number of plays n into account). Another contribution of this paper is to design robust anytime policies for specific multi-armed bandit problems in which some restrictions are put on the set of possible distributions of the different arms. We also show that, for any policy (i.e. even when the number of plays n is known), the regret is of order log n with probability at least , so that the policy of Audibert et al. has the best possible deviation properties. [Copyright &y& Elsevier]

Abstract: There are many folded states consistent with a given mountain–valley pattern of equidistant creases on a long paper strip. We would like to fold a paper strip such that the number of paper layers between each pair of hinged paper segments, called the crease width at the crease point, is minimized. This problem is called the stamp folding problem and there are two variants of this problem: minimization of the maximum crease width, and minimization of the total crease width. This optimization problem was recently introduced and investigated from the viewpoint of the counting problem. However, its computational complexity is not known. In this paper, we first show that the minimization problem of the maximum crease width is strongly NP-complete. Hence we cannot solve the problem in polynomial time unless P=NP. We next propose an algorithm that solves the minimization problem. The algorithm itself is a straightforward one, but its analysis is not trivial. We show that this algorithm runs in time where is the number of creases and is the total crease width. [Copyright &y& Elsevier]

Abstract: We consider perfect-information reachability stochastic games for 2 players on countable graphs. Such a game is strongly determined if, whenever we fix an inequality and a threshold , either Player Max has a strategy which forces the value of the game to satisfy against any strategy of Player Min, or Min has a strategy which forces the opposite against any strategy of Max. One of our results shows that whenever one of the players has an optimal strategy in every state of a game, then this game is strongly determined. This significantly generalises, e.g., recent results on finitely-branching reachability games. For strong determinacy, our methods are substantially different, based on which player has the optimal strategy, because the roles of the players are not symmetric. We also do not restrict the branching of the games, and where we provide an extension of results for finitely-branching games, we had to overcome significant complications and employ new methods as well. The other result is finding a subclass of stochastic games where Player Max has an optimal strategy in each state. The subclass is defined by the property that if is an accumulation point of the set of all values of a game then . These results complement recent results classifying the existence of an optimal strategy for Player Min, and our general strong-determinacy theorem applies here as well. We also apply our results for Max in the context of recently studied One-Counter stochastic games. This work extends a workshop version of this paper which appeared in GandALF 2011, in particular, we prove a conjecture raised in that paper for the class of all reachability games. [Copyright &y& Elsevier]

The n -dimensional torus T ( k 1 , k 2 , … , k n ) (including the k -ary n -cube Q n k ) is one of the most popular interconnection networks. A paired k -disjoint path cover (paired k -DPC for short) of a graph is a set of k disjoint paths joining k distinct source-sink pairs that cover all vertices of the graph. In this paper, we consider the paired 2-DPC problem of n -dimensional torus. Assuming k i ≥ 3 for i = 1 , 2 , … , n , with at most one k i being even, then T ( k 1 , k 2 , … , k n ) with at most 2 n − 3 faulty edges always has a paired 2-DPC. And the upper bound 2 n − 3 of edge faults tolerated is optimal. The result is a supplement of the results of Chen [3] and [4] . [ABSTRACT FROM AUTHOR]

In wireless ad hoc networks, maintaining network connectivity is very important as high level network functions all depend on it. However, how to measure network connectivity remains a fundamental challenge. For example, a network can have good overall k -connectivity and yet still have a communication bottleneck. In this paper, we address how to locate bottlenecks and relieve them. A new connectivity measure based on the Cheeger's Constant is used for bottleneck discovery, and a partition algorithm that divides the network at the bottleneck is developed. After the network is partitioned, we consider deploying a relay node to increase the conductance of the network across the partition. The relay node deployment problem is formulated as an integer linear program to maximize the number of connections between the two sides of the cut, and then a convex optimization algorithm is used to find the precise location of the relay node, which is within the convex hull defined by the radio transmission ranges of all the nodes that can connect to the relay node. We show that the relay node significantly relieves the bottleneck and improves network connectivity, which is manifested by several network connectivity metrics. The partition and relay node deployment algorithms are then extended to the case where multiple relay nodes are available. Multiway partition and multiple relay node deployment algorithms are presented. Simulation results show this approach effectively enhances network connectivity with a small number of relay nodes. [ABSTRACT FROM AUTHOR]

Link-cut trees have been introduced by D.D. Sleator and R.E. Tarjan [12] with the aim of efficiently maintaining a forest of vertex-disjoint dynamic rooted trees under cut and link operations. These operations respectively disconnect a subtree from a tree, and join two trees by an edge. Additionally, link-cut trees allow to change the root of a tree and to perform a number of updates and queries on cost values defined on the arcs of the trees. All these operations are performed in O ( log ⁡ n ) amortized or worst-case time, depending on the implementation, where n is the total size of the forest. In this paper, we show that a list of elements implemented using link-cut trees (we call it a log -list ) allows us to obtain a common running time of O ( log ⁡ n ) for the classical operations on lists, but also for some other essential operations that usually take linear time on lists. Such operations require to find the minimum/maximum element in a sublist defined by its endpoints, the position of a given element in the list or the element placed at a given position in the list; or they require to add a value a , or to multiply by −1, all the elements in a sublist. Furthermore, we use log-lists to implement several existing algorithms for sorting permutations by transpositions and/or reversals and/or block-interchanges, and obtain O ( n log ⁡ n ) running time for all of them. In this way, the running time of several algorithms is improved, whereas in other cases our algorithms perform as well as the best existing implementations. [ABSTRACT FROM AUTHOR]

The conditional diagnosability of many well-known networks has been explored. In this paper, we analyze the conditional diagnosability of a family of networks, called the round matching composition networks, which are a class of networks composed of r ( r ≥ 4 ) components of the same order linked by r perfect matchings. Applying the result, we determine the conditional diagnosability of the k -ary n -cubes and the recursive circulant graphs under the PMC model and the MM model, respectively. [ABSTRACT FROM AUTHOR]

Abstract: This paper describes the biological and theoretical foundations of a new Artificial Immune System the Receptor Density Algorithm. The algorithm is developed with inspiration from T cell signalling processes and has application in anomaly detection. Connections between the Receptor Density Algorithm and kernel density estimation with exponential smoothing are demonstrated. Finally, the paper evaluates the algorithm’s performance on two types of anomaly detection problem. [Copyright &y& Elsevier]

Visibly Pushdown Automata ( VPA ) are a special case of pushdown machines where the stack operations are driven by the input. In this paper, we consider VPA with multiple stacks , namely n-VPA , with n > 1 . These automata introduce a useful model to effectively describe concurrent pushdown systems using a simple communication mechanism between stacks. We show that n -VPA are strictly more expressive than VPA. Indeed, n -VPA accept some context-sensitive languages that are not context-free and some context-free languages that are not accepted by any VPA. Nevertheless, we show that the class of languages accepted by n -VPA is closed under union and intersection. On the contrary, this class turns out to be neither closed under complementation nor determinizable. Moreover, we show that the emptiness problem for n -VPA is undecidable. By adding an ordering constraint on stacks ( n -OVPA), decidability of emptiness can be recovered, as well as the closure under complementation. Using these properties along with the automata-theoretic approach, one can prove that the model checking problem over n -OVPA models against n -OVPA specifications is decidable. [ABSTRACT FROM AUTHOR]

Asynchronously communicating systems involve peers or entities that communicate by exchanging messages via buffers. In general, the size of such buffers is not known apriori, i.e., they are considered to be unbounded. As a result, models of asynchronously communicating systems typically exhibit infinite state spaces and it is well-known that reachability and boundedness problems for such models are undecidable. This, in turn, makes automatic verification of asynchronous systems undecidable as well. We discuss a particular class of asynchronous systems over peers for which the interaction behaviors do not change when the peers are made to communicate synchronously. Such systems are referred to as Synchronizable . Automatic verification of synchronizable systems is decidable as the verification of the system can be performed using its synchronous counterpart. Recently, we have proved that checking whether or not a system is synchronizable is decidable. In this paper, we consider different types of asynchronous communication, where the type is described in terms of the nature of buffering and the number of buffers, and discuss how/if synchronizability is decidable for each type. The new results subsume the existing ones and present a comprehensive synchronizability study of asynchronous systems. [ABSTRACT FROM AUTHOR]

Parameterized Approximation is a topic of considerable interest in the field of Parameterized Complexity. In the past decade, new color coding-related techniques, including the breakthrough representative sets technique, have been proven extremely powerful in the design of fast parameterized algorithms. Furthermore, packing problems, which are often solved via color coding-related techniques, have enjoyed a race towards obtaining the fastest parameterized algorithms that solve them. Therefore, it is natural to ask whether packing problems admit efficient parameterized approximation algorithms. In this paper, we answer this question affirmatively. We present tradeoffs that improve the running times of algorithms for well-known special cases of the 3 -Set k -Packing problem at the cost of their accuracy. Consider a packing problem for which there is no known algorithm with approximation ratio α , and a parameter k . If the value of an optimal solution is at least k , we seek a solution of value at least αk ; otherwise, we seek an arbitrary solution. Clearly, if the best known parameterized algorithm that finds a solution of value t runs in time O ⁎ ( f ( t ) ) for some function f , we are interested in running times better than O ⁎ ( f ( α k ) ) . Our main contribution lies in the adaptation of notions fundamental to the representative sets technique to the design of approximation algorithms: We introduce the definition of “approximate lopsided universal sets”, combine partial executions of representative sets-based algorithms with approximation algorithms, and adapt the iterative expansion framework (in the context of representative sets) to the design of parameterized approximation algorithms. Our ideas are intuitive, and may be relevant to the design of other parameterized approximation algorithms. [ABSTRACT FROM AUTHOR]

The combinatorics of nonstandard squares in a word depends on how the equivalence of halves of the square is defined. We consider Abelian squares, parameterized squares, and order-preserving squares. The word uv is an Abelian (parameterized, order-preserving) square if u and v are equivalent in the Abelian (parameterized, order-preserving) sense. The maximum number of ordinary squares in a word is known to be asymptotically linear, but the exact bound is still investigated. We present several results on the maximum number of distinct squares for nonstandard factor equivalence relations. Let SQ Abel ( n , σ ) and SQ Abel ′ ( n , σ ) denote the maximum number of Abelian squares in a word of length n over an alphabet of size σ which are distinct as words and which are nonequivalent in the Abelian sense, respectively. For σ ≥ 2 we prove that SQ Abel ( n , σ ) = Θ ( n 2 ) , SQ Abel ′ ( n , σ ) = Ω ( n 3 / 2 ) and SQ Abel ′ ( n , σ ) = O ( n 11 / 6 ) . We also give linear bounds for parameterized and order-preserving squares for alphabets of constant size: SQ param ( n , O ( 1 ) ) = Θ ( n ) , SQ op ( n , O ( 1 ) ) = Θ ( n ) . The upper bounds have quadratic dependence on the alphabet size for order-preserving squares and exponential dependence for parameterized squares. As a side result we construct infinite words over the smallest alphabet which avoid nontrivial order-preserving squares and nontrivial parameterized cubes (nontrivial parameterized squares cannot be avoided in an infinite word). A preliminary version of this paper was published at DLT 2014 [24] . In this full version we improve or extend the bounds on all three kinds of squares. [ABSTRACT FROM AUTHOR]

Set intersections are important in computer science. Especially, intersection of inverted lists is a fundamental operation in information retrieval for text databases and Web search engines. In this paper, we discuss an efficient and effective way to implement this operation in the context of very big data sets. The main idea behind it is to do a binary search over sorted interval sequences, each of which corresponds to an inverted list and is constructed by establishing a trie over the sequences of set identifiers as well as a kind of tree encoding, by which each node in the trie is assigned an interval. In many cases, an interval sequence is much shorter than its corresponding inverted list. In particular, the lowest common ancestors of intervals in a trie can be utilized to control a binary search to skip over useless interval containment checks, which enables us to reach an optimal off-line algorithm to do the task, and is theoretically better than any traditional on-line methods (at cost of more space). Experiments have been conducted, showing that the trade-off of space for time is worthwhile. [ABSTRACT FROM AUTHOR]

Abstract: Reaction systems are a formal model based on the regulation mechanisms of facilitation and inhibition between biochemical reactions, which underlie the functioning of living cells. The aim of this paper is to explore the expressive power of reaction systems as a modeling framework, showing how their basic assumptions and properties can be exploited to formalize computer science and biology oriented problems. In this view, we first provide a reaction-based description of an iterative algorithm to solve the Tower of Hanoi puzzle. Then, we show how the regulation of gene expression in the lac operon, involved in the metabolism of lactose in Escherichia coli cells, can be formalized in terms of reaction systems. Finally, we present a method to derive, given a reaction system with reactions, a functionally equivalent system with reactions using simplification methods of boolean expressions. Some final remarks and directions for future research conclude the paper. [Copyright &y& Elsevier]

Abstract: In this paper, we prove the coincidence between strong/weak context bisimulation and strong/weak normal bisimulation for higher order -calculus, which generalizes Sangiorgi’s work. To achieve this aim, we introduce indexed higher order -calculus, which is similar to higher order -calculus except that every prefix of any process is assigned indices. Furthermore we present corresponding indexed bisimulations for this calculus, and prove the equivalence between these indexed bisimulations. Based on this result, we prove the main result of this paper, i.e., the equivalence between strong/weak context bisimulation and strong/weak normal bisimulation. [Copyright &y& Elsevier]

Abstract: The utilization of populations is one of the most important features of evolutionary algorithms (EAs). There have been many studies analyzing the impact of different population sizes on the performance of EAs. However, most of such studies are based on computational experiments, except for a few cases. The common wisdom so far appears to be that a large population would increase the population diversity and thus help an EA. Indeed, increasing the population size has been a commonly used strategy in tuning an EA when it did not perform as well as expected for a given problem. He and Yao (2002)  showed theoretically that for some problem instance classes, a population can help to reduce the runtime of an EA from exponential to polynomial time. This paper analyzes the role of population further in EAs and shows rigorously that large populations may not always be useful. Conditions, under which large populations can be harmful, are discussed in this paper. Although the theoretical analysis was carried out on one multimodal problem using a specific type of EAs, it has much wider implications. The analysis has revealed certain problem characteristics, which can be either the problem considered here or other problems, that lead to the disadvantages of large population sizes. The analytical approach developed in this paper can also be applied to analyzing EAs on other problems. [Copyright &y& Elsevier]

Abstract: In this paper, we prove decidability properties and new results on the position of the family of languages generated by (circular) splicing systems within the Chomsky hierarchy. The two main results of the paper are the following. First, we show that it is decidable, given a circular splicing language and a regular language, whether they are equal. Second, we prove the language generated by an alphabetic splicing system is context-free. Alphabetic splicing systems are a generalization of simple and semi-simple splicing systems already considered in the literature. [Copyright &y& Elsevier]

Abstract: The aim of this paper is to obtain a theoretical foundation of inconsistency-tolerant (or paraconsistent) reasoning by presenting a comprehensive study of the structural proof-theory of David Nelson’s paraconsistent logic. Inconsistency handling has a growing importance in Computer Science since inconsistencies may frequently occur in knowledge-based and intelligent information systems. Paraconsistent, inconsistency-tolerant logics have been studied to cope with such inconsistencies. In this paper, proof systems for Nelson’s paraconsistent logic N4 are comprehensively studied. The logic N4 is a fundamental system and known to be a common basis for various extended and useful paraconsistent logics. Some basic theorems including cut-elimination, normalization and completeness are uniformly proved using various embedding theorems. A variety of sequent calculi and natural deduction systems for N4 and some closely related systems are presented and compared. [Copyright &y& Elsevier]

Abstract: Faugère’s algorithm is one of the fastest algorithms to compute Gröbner bases. It uses two criteria namely the criterion and the IsRewritten criterion to detect the useless critical pairs (see Faugère (2002) ). The IsRewritten criterion has been used in the algorithm, but it has not been explicitly declared in the related paper. In this paper, we give first a complete proof for the IsRewritten criterion and then using a signature structure on Buchberger’s algorithm, we apply this criterion on Buchberger’s algorithm. We have implemented a new algorithm (based on the above results) in Maple to compute a Gröbner basis of a general ideal and we evaluate its performance via some examples. [Copyright &y& Elsevier]