Acta Informatica最新文献

Laplacian matrix and its spectrum are commonly used for giving a measure in networks in order to analyse its topological properties. In this paper, Laplacian matrix of graphs and their spectrum are studied. Laplacian energy of a graph G of order n is defined as ( mathrm{{LE}}(G) = sum _{i=1}^n|lambda _i(L)-{bar{d}}|), where (lambda _i(L)) is the i-th eigenvalue of Laplacian matrix of G, and ({bar{d}}) is their average. If (mathrm{{LE}}(G) = mathrm{{LE}}(K_n)) for the complete graph (K_n) of order n, then G is known as L-borderenergetic graph. In the first part of this paper, we construct three infinite families of non-complete disconnected L-borderenergetic graphs: (Lambda _1 = { G_{b,j,k} = [(((j-2)k-2j+2)b+1)K_{(j-1)k-(j-2)}] cup b(K_j times K_k)| b,j,k in {{mathbb {Z}}}^+}), ( Lambda _2 = {G_{2,b} = [K_6 nabla b(K_2 times K_3)] cup (4b-2)K_9 | bin {{mathbb {Z}}}^+ }), ( Lambda _3 = {G_{3,b} = [bK_8 nabla b(K_2 times K_4)] cup (14b-4)K_{8b+6} | bin {{mathbb {Z}}}^+ }), where (nabla ) is join operator and (times ) is direct product operator on graphs. Then, in the second part of this work, we construct new infinite families of non-complete connected L-borderenergetic graphs (Omega _1= {K_2 nabla overline{aK_2^r} vert ain {{mathbb {Z}}}^+}), (Omega _2 = {overline{aK_3 cup 2(K_2times K_3)}vert ain {{mathbb {Z}}}^+ }) and (Omega _3 = {overline{aK_5 cup (K_3times K_3)}vert ain {{mathbb {Z}}}^+ }), where ({overline{G}}) is the complement operator on G.

We present a new FPTAS for the Subset Sum Ratio problem, which, given a set of integers, asks for two disjoint subsets such that the ratio of their sums is as close to 1 as possible. Our scheme makes use of exact and approximate algorithms for Partition, and clearly showcases the close relationship between the two algorithmic problems. Depending on the relationship between the size of the input set n and the error margin (varepsilon ), we improve upon the best currently known algorithm of Melissinos and Pagourtzis [COCOON 2018] of complexity (mathcal {O} (n^4 / varepsilon )). In particular, the exponent of n in our proposed scheme may decrease down to 2, depending on the Partition algorithm used.

Motivated by the need to convert move-atomic assumption in LOOK-COMPUTE-MOVE (LCM) robot algorithms to be implemented in existing distributed systems, we define a new distributed fundamental task, the neighborhood mutual remainder (NMR). Consider a situation where each process has a set of operations (O_p) and executes each operation in (O_p) infinitely often in distributed systems. Then, let (O_esubset O_p) be a subset of operations, which a process cannot execute, while its closed neighborhood executes operations in (O_psetminus O_e). The NMR is defined for such a situation. A distributed algorithm that satisfies the NMR requirement should satisfy the following two properties: (1) Liveness is satisfied if a process executes each operation in (O_p) infinitely often and (2) safety is satisfied if, when each process executes operations in (O_e), no process in its closed neighborhood executes operations in (O_psetminus O_e). We formalize the concept of NMR and give a simple self-stabilizing algorithm using the pigeon-hole principle to demonstrate the design paradigm to achieve NMR. A self-stabilizing algorithm tolerates transient faults (e.g., message loss, memory corruption, etc.) by its ability to converge from an arbitrary configuration to the legitimate one. In addition, we present an application of NMR to an LCM robot system for implementing a move-atomic property, where robots possess an independent clock that is advanced at the same speed. It is the first self-stabilizing implementation of the LCM synchronization for environments where each robot can have limited visibility and lights.

In this paper, n-PS-codes, 2-infix-outfix codes and some related classes of codes are investigated where (nge 1). The classes of n-PS-codes and 2-infix-outfix codes are generalizations of classes of prefix codes and suffix codes, and infix codes and outfix codes, respectively. The closure properties of n-PS-codes and g-3-PS-codes under composition are discussed where (nge 1), and the condition under which the class of 2-infix-outfix codes is closed under composition is provided.

We investigate the performance of random m-ary trees grown under an algorithm that perfectly balances k levels, whenever the opportunity arises in a fringe subtree. The average-case analysis shows that considerable saving in space and search time is achieved by such a fringe balancing algorithm.

String constraint solving is the core of various testing and verification approaches for scripting languages. Among algorithms for solving string constraints, flattening is a well-known approach that is particularly useful in handling satisfiable instances. As string/integer conversion is an important function appearing in almost all scripting languages, Abdulla et al. extended the flattening approach to this function recently. However, their approach supports only a special flattening pattern and leaves the support of the general flat regular constraints as an open problem. In this paper, we fill the gap by proposing a complete flattening approach for the string/integer conversion. The approach is built upon a new quantifier elimination procedure for the linear-exponential arithmetic (namely, the extension of Presburger arithmetic with exponential functions, denoted by ExpPA) improved from the one proposed by Cherlin and Point in 1986. We analyze the complexity of our quantifier elimination procedure and show that the decision problem for existential ExpPA formulas is in 3-EXPTIME. Up to our knowledge, this is the first elementary complexity upper bound for this problem. While the quantifier elimination procedure is too expensive to be implemented efficiently, we propose various optimizations and provide a prototypical implementation. We evaluate the performance of our implementation on the benchmarks that are generated from the string hash functions as well as randomly. The experimental results show that our implementation outperforms the state-of-the-art solvers.

A novel and efficient method for discovering concurrent workflow processes is presented. It allows building a suitable workflow net (WFN) from a large event log (lambda ), which represents the behaviour of complex iterative processes involving concurrency. First, the t-invariants are determined from (lambda ); this allows computing the causal and concurrent relations between the events and the implicit causal relations between events that do not appear consecutively in (lambda ). Then a 1-bounded WFN is built, which could be eventually adjusted if its t-invariants do not match with those computed from (lambda ). The discovered model allows firing all the traces in (lambda ). The procedures derived from the method are polynomial time on (|lambda |); they have been implemented and tested on artificial logs.

In the fields of combinatorics on words and theory of codes, a two-word language ({x, y}) is a code if and only if (xy not = yx). But up to now, corresponding characterizations for a three-word language, which forms a code, have not been completely found. Let (X={x, y, z}) be a three-word language and (|x|, |y|, |z|) be their lengths. When (|x| = |y| < |z|), a necessary and sufficient condition for X to be a code was obtained in 2018. If (|x| < |y| = |z| le 2|x|), a necessary and sufficient condition for X to be a code is proposed in this paper.

Runtime enforcement is a dynamic analysis technique that uses monitors to enforce the behaviour specified by some correctness property on an executing system. The enforceability of a logic captures the extent to which the properties expressible via the logic can be enforced at runtime for a specified operational model of enforcing monitors. We study the enforceability of branching-time, first-order properties expressed in the Hennessy–Milner Logic with Recursion ((mu ) HML) with respect to monitors that can enforce behaviour involving events that carry data. To this end, we develop an operational framework for first-order enforcement via suppressions, insertions and replacements. We then use this model to formalise the meaning of enforcing a branching-time property. We also show that a safety syntactic fragment of the logic is enforceable within this framework by providing an automated synthesis function that generates correct suppression monitors from any formula taken from this logical fragment.