Acta Informatica最新文献

In this paper, we present an encoding of the (lambda )-calculus in a multiset rewriting system and provide a few applications of the construction. For this purpose, we choose the calculus named String MultiSet Rewriting, which was introduced in Barbuti et al. (Electron Notes Theor Comput Sci 194:19–34, 2008) by Barbuti et al. With the help of our encoding, we give alternative proofs for the standardization and the finiteness of developments theorems in the (lambda )-calculus.

Simon’s problem is one of the most important problems demonstrating the power of quantum algorithms, as it greatly inspired the proposal of Shor’s algorithm. The generalized Simon’s problem is a natural extension of Simon’s problem and also a special hidden subgroup problem: Given a function (f:{0,1}^n rightarrow {0,1}^m), it is promised that there exists a hidden subgroup (Sle mathbb {Z}_2^n) of rank k such that for any (x, yin {{0, 1}}^n), (f(x) = f(y)) iff (x oplus y in S). The goal of generalized Simon’s problem is to find the hidden subgroup S. In this paper, we present two key contributions. Firstly, we characterize the structure of the generalized Simon’s problem in distributed scenario and introduce a corresponding distributed quantum algorithm. Secondly, we refine the algorithm to ensure exactness due to the application of quantum amplitude amplification technique. Our algorithm offers exponential speedup compared to the distributed classical algorithm. When contrasted with the quantum algorithm for the generalized Simon’s problem, our algorithm’s oracle requires fewer qubits, thus making it easier to be physically implemented. Particularly, the exact distributed quantum algorithm we develop for the generalized Simon’s problem outperforms the best previously proposed distributed quantum algorithm for Simon’s problem in terms of generalizability and exactness.

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.