# Acta Informatica

Online ISSN: 1432-0525
Print ISSN: 0001-5903
Recent publications
We consider a generalization of the classical 100 prisoner problem and its variant, involving empty boxes, whereby winning probabilities for a team depend on the number of attempts, as well as on the number of winners. We call this the unconstrained 100 prisoner problem. After introducing the 3 main classes of strategies, we define a variety of ‘hybrid’ strategies and quantify their winning-efficiency. Whenever analytic results are not available, we make use of Monte Carlo simulations to estimate with high accuracy the winning probabilities. Based on the results obtained, we conjecture that all strategies, except for the strategy maximizing the winning probability of the classical (constrained) problem, converge to the random strategy under weak conditions on the number of players or empty boxes. We conclude by commenting on the possible applications of our results in understanding processes of information retrieval, such as “memory” in living organisms.

Message-based systems are usually distributed in nature, and distributed components collaborate via asynchronous message passing. In some cases, particular ordering among the messages may lead to violation of the desired properties such as data confidentiality. Due to the absence of a global clock and usage of off-the-shelf components, such unwanted orderings can be neither statically inspected nor verified by revising their codes at design time. We propose a choreography-based runtime verification algorithm that given an automata-based specification of unwanted message sequences detects the formation of the unwanted sequences. Our algorithm is fully decentralized in the sense that each component is equipped with a monitor, as opposed to having a centralized monitor, and also the specification of the unwanted sequences is decomposed among monitors. In this way, when a component sends a message, its monitor inspects if there is a possibility for the formation of unwanted message sequences. As there is no global clock in message-based systems, monitors cannot determine the exact ordering among messages. In such cases, they decide conservatively and declare a sequence formation even if that sequence has not been formed. We prevent such conservative declarations in our algorithm as much as possible and then characterize its operational guarantees. We evaluate the efficiency and scalability of our algorithm in terms of the communication overhead, the memory consumption, and the latency of the result declaration through simulation.

A temporal graph with lifetime L is a sequence of L graphs $$G_1, \ldots ,G_L$$ G 1 , … , G L , called layers, all of which have the same vertex set V but can have different edge sets. The underlying graph is the graph with vertex set V that contains all the edges that appear in at least one layer. The temporal graph is always connected if each layer is a connected graph, and it is k -edge-deficient if each layer contains all except at most k edges of the underlying graph. For a given start vertex s , a temporal exploration is a temporal walk that starts at s , traverses at most one edge in each layer, and visits all vertices of the temporal graph. We show that always-connected, k -edge-deficient temporal graphs with sufficient lifetime can always be explored in $$O(kn \log n)$$ O ( k n log n ) time steps. We also construct always-connected, k -edge-deficient temporal graphs for which any exploration requires $$\varOmega (n \log k)$$ Ω ( n log k ) time steps. For always-connected, 1-edge-deficient temporal graphs, we show that O ( n ) time steps suffice for temporal exploration.

Traditionally, graph algorithms get a single graph as input, and then they should decide if this graph satisfies a certain property Φ. What happens if this question is modified in a way that we get a possibly infinite family of graphs as an input, and the question is if there is a graph satisfying Φ in the family? We approach this question by using formal languages for specifying families of graphs, in particular by regular sets of words. We show that certain graph properties can be decided by studying the syntactic monoid of the specification language L if a certain torsion condition is satisfied. This condition holds trivially if L is regular. More specifically, we use a natural binary encoding of finite graphs over a binary alphabet Σ, and we define a regular set G⊆Σ∗ such that every nonempty word w∈G defines a finite and nonempty graph. Also, graph properties can then be syntactically defined as languages over Σ. Then, we ask whether the automaton A specifies some graph satisfying a certain property Φ. Our structural results show that we can answer this question for all “typical” graph properties. In order to show our results, we split L into a finite union of subsets and every subset of this union defines in a natural way a single finite graph F where some edges and vertices are marked. The marked graph in turn defines an infinite graph F∞ and therefore the family of finite subgraphs of F∞ where F appears as an induced subgraph. This yields a geometric description of all graphs specified by L based on splitting L into finitely many pieces; then using the notion of graph retraction, we obtain an easily understandable description of the graphs in each piece.

The regular intersection emptiness problem for a decision problem P ( $${{\textit{int}}_{{\mathrm {Reg}}}}$$ int Reg ( P )) is to decide whether a potentially infinite regular set of encoded P -instances contains a positive one. Since $${{\textit{int}}_{{\mathrm {Reg}}}}$$ int Reg ( P ) is decidable for some NP-complete problems and undecidable for others, its investigation provides insights in the nature of NP-complete problems. Moreover, the decidability of the $${{\textit{int}}_{{\mathrm {Reg}}}}$$ int Reg -problem is usually achieved by exploiting the regularity of the set of instances; thus, it also establishes a connection to formal language and automata theory. We consider the $${{\textit{int}}_{{\mathrm {Reg}}}}$$ int Reg -problem for the well-known NP-complete problem Integer Linear Programming ( ILP ). It is shown that any DFA that describes a set of ILP -instances (in a natural encoding) can be reduced to a finite core of instances that contains a positive one if and only if the original set of instances did. This result yields the decidability of $${{\textit{int}}_{{\mathrm {Reg}}}}$$ int Reg ( ILP ).

It cannot be decided whether a pushdown automaton accepts using a pushdown height, which does not depend on the input length, i.e., when it accepts using constant height. Furthermore, when a pushdown automaton accepts in constant height, the height can be arbitrarily large with respect to the size of the description of the machine, namely it does not exist any recursive function in the size of the description of the machine bounding the height of the pushdown. In contrast, in the restricted case of pushdown automata over a one-letter input alphabet, i.e., unary pushdown automata, the situation is different. First, acceptance in constant height is decidable. Moreover, in the case of acceptance in constant height, the height is at most exponential with respect to the size of the description of the pushdown automaton. We also prove a matching lower bound. Finally, if a unary pushdown automaton uses nonconstant height to accept, then the height should grow at least as the logarithm of the input length. This bound is optimal.

In this paper, the regular languages of wire linear AC0\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\hbox {AC}^0$$\end{document}are characterized as the languages expressible in the two-variable fragment of first-order logic with regular predicates, FO2[reg]\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\mathrm{FO}^2[\mathrm{reg}]$$\end{document}. Additionally, they are characterized as the languages recognized by the algebraic class QLDA\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\mathbf {QLDA}$$\end{document}. The class is shown to be decidable and examples of languages in and outside of it are presented.

Parameterized complexity allows us to analyze the time complexity of problems with respect to a natural parameter depending on the problem. Reoptimization looks for solutions or approximations for problem instances when given solutions to neighboring instances. We combine both techniques, in order to better classify the complexity of problems in the parameterized setting. Specifically, we see that some problems in the class of compositional problems, which do not have polynomial kernels under standard complexity-theoretic assumptions, do have polynomial kernels under the reoptimization model for some local modifications. We also observe that, for some other local modifications, these same problems do not have polynomial kernels unless $$\mathbf{NP}\subseteq \mathbf{coNP/poly}$$ NP ⊆ coNP / poly . We find examples of compositional problems, whose reoptimization versions do not have polynomial kernels under any of the considered local modifications. Finally, in another negative result, we prove that the reoptimization version of Connected Vertex Cover does not have a polynomial kernel unless Set Cover has a polynomial compression. In a different direction, looking at problems with polynomial kernels, we find that the reoptimization version of Vertex Cover has a polynomial kernel of size $$\varvec{2k+1}$$ 2 k + 1 using crown decompositions only, which improves the size of the kernel achievable with this technique in the classic problem.

We approach the task of computing a carefully synchronizing word of minimum length for a given partial deterministic automaton, encoding the problem as an instance of SAT and invoking a SAT solver. Our experiments demonstrate that this approach gives satisfactory results for automata with up to 100 states even if very modest computational resources are used. We compare our results with the ones obtained by the first author for exact synchronization, which is another version of synchronization studied in the literature, and draw some theoretical conclusions.

The well-known pumping lemma for regular languages states that, for any regular language L , there is a constant p (depending on L ) such that the following holds: If $$w\in L$$ w ∈ L and $$\vert w\vert \ge p$$ | w | ≥ p , then there are words $$x\in V^{*}$$ x ∈ V ∗ , $$y\in V^+$$ y ∈ V + , and $$z\in V^{*}$$ z ∈ V ∗ such that $$w=xyz$$ w = x y z and $$xy^tz\in L$$ x y t z ∈ L for $$t\ge 0$$ t ≥ 0 . The minimal pumping constant $${{{\,\mathrm{mpc}\,}}(L)}$$ mpc ( L ) of L is the minimal number p for which the conditions of the pumping lemma are satisfied. We investigate the behaviour of $${{{\,\mathrm{mpc}\,}}}$$ mpc with respect to operations, i. e., for an n -ary regularity preserving operation $$\circ$$ ∘ , we study the set $${g_{\circ }^{{{\,\mathrm{mpc}\,}}}(k_1,k_2,\ldots ,k_n)}$$ g ∘ mpc ( k 1 , k 2 , … , k n ) of all numbers k such that there are regular languages $$L_1,L_2,\ldots ,L_n$$ L 1 , L 2 , … , L n with $${{{\,\mathrm{mpc}\,}}(L_i)=k_i}$$ mpc ( L i ) = k i for $$1\le i\le n$$ 1 ≤ i ≤ n and $${{{\,\mathrm{mpc}\,}}(\circ (L_1,L_2,\ldots ,L_n)=~k}$$ mpc ( ∘ ( L 1 , L 2 , … , L n ) = k . With respect to Kleene closure, complement, reversal, prefix and suffix-closure, circular shift, union, intersection, set-subtraction, symmetric difference,and concatenation, we determine $${g_{\circ }^{{{\,\mathrm{mpc}\,}}}(k_1,k_2,\ldots ,k_n)}$$ g ∘ mpc ( k 1 , k 2 , … , k n ) completely. Furthermore, we give some results with respect to the minimal pumping length where, in addition, $$\vert xy\vert \le p$$ | x y | ≤ p has to hold.

We consider the problem of weighted throughput in the single machine preemptive scheduling with continuous controllable processing times. A set of tasks can be scheduled on a single machine. Each task j is associated with a nonnegative weight wj\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$w_{j}$$\end{document}, a release date, a due date, and an interval of possible processing times. A task j can either be scheduled with a total processing time pj\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$p_j$$\end{document} which is in the given interval, or rejected (not participating in the schedule). The reward for processing j for pj\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$p_{j}$$\end{document} time units is wjpj\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$w_{j}p_{j}$$\end{document}, and we are interested in constructing a feasible preemptive schedule such that the sum of rewards is maximized. We present a dynamic programming algorithm that solves the problem in pseudo-polynomial time and use it to obtain an FPTAS. Afterward, as our main contribution we propose an interesting efficient frontier approach for improved complexity bounds.

This paper considers the structure consisting of the set of all words over a given alphabet together with the subword relation, regular predicates, and constants for every word. We are interested in the counting extension of first-order logic by threshold counting quantifiers. The main result shows that the two-variable fragment of this logic can be decided in twofold exponential alternating time with linearly many alternations (and therefore in particular in twofold exponential space as announced in the conference version (Kuske and Schwarz, in: MFCS’20, Leibniz International Proceedings in Informatics (LIPIcs) vol. 170, pp 56:1–56:13. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2020) of this paper) provided the regular predicates are restricted to piecewise testable ones. This result improves prior insights by Karandikar and Schnoebelen by extending the logic and saving one exponent in the space bound. Its proof consists of two main parts: First, we provide a quantifier elimination procedure that results in a formula with constants of bounded length (this generalises the procedure by Karandikar and Schnoebelen for first-order logic). From this, it follows that quantification in formulas can be restricted to words of bounded length, i.e., the second part of the proof is an adaptation of the method by Ferrante and Rackoff to counting logic and deviates significantly from the path of reasoning by Karandikar and Schnoebelen.

This paper investigates presentations of lamplighter groups using computational models from automata theory. The present work shows that if G can be presented such that the full group operation is recognised by a transducer, then the same is true for the lamplighter group G≀Z of G. Furthermore, Cayley presentations, where only multiplications with constants are recognised by transducers, are used to study generalised lamplighter groups of the form G≀Zd and G≀Fd, where Fd is the free group over d generators. Additionally, Zk≀Z2 and Zk≀Fd are shown to be Cayley tree automatic.

We present an algorithm for constructing a depth-first search tree in planar digraphs; the algorithm can be implemented in the complexity class AC1(UL∩co-UL)\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\text{ AC}^1(\text{ UL }\cap \text{ co-UL})$$\end{document}, which is contained in AC2\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\text{ AC}^2$$\end{document}. Prior to this (for more than a quarter-century), the fastest uniform deterministic parallel algorithm for this problem had a runtime of O(log10n)\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$O(\log ^{10}n)$$\end{document} (corresponding to the complexity class AC10⊆NC11\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\text{ AC}^{10}\subseteq \text{ NC}^{11}$$\end{document}). We also consider the problem of computing depth-first search trees in other classes of graphs and obtain additional new upper bounds.

We formalize several regular numeral systems, state their properties and supported operations, clarify the correctness, and tabulate the proofs. Our goal is to use as few symbols in the presentation of digits and make as few digit changes as possible in every operation. Most importantly, we introduce two new systems: (1) the buffered regular system is simple and allows the increment and decrement of the least-significant digit in constant time, and (2) the strictly regular system allows the increment and decrement of a digit at arbitrary position with a constant number of digit changes while using three symbols only (instead of four symbols required by the extended regular system). To demonstrate the usefulness of the regular systems, we survey how they have been used in the design of data structures.

In this paper, we deal with the lumpability approach to cope with the state space explosion problem inherent to the computation of the stationary performance indices of large stochastic models. The lumpability method is based on a state aggregation technique and applies to Markov chains exhibiting some structural regularity. Moreover, it allows one to efficiently compute the exact values of the stationary performance indices when the model is actually lumpable. The notion of quasi-lumpability is based on the idea that a Markov chain can be altered by relatively small perturbations of the transition rates in such a way that the new resulting Markov chain is lumpable. In this case, only upper and lower bounds on the performance indices can be derived. Here, we introduce a novel notion of quasi-lumpability, named proportional lumpability , which extends the original definition of lumpability but, differently from the general definition of quasi-lumpability, it allows one to derive exact stationary performance indices for the original process. We then introduce the notion of proportional bisimilarity for the terms of the performance process algebra PEPA. Proportional bisimilarity induces a proportional lumpability on the underlying continuous-time Markov chains. Finally, we prove some compositionality results and show the applicability of our theory through examples.

We present an automated system repair framework for cyber-physical systems. The proposed framework consists of three main steps: (1) system simulation and fault detection to generate a labeled dataset, (2) identification of the repairable temporal properties leading to the faulty behavior and (3) repairing the system to avoid the occurrence of the cause identified in the second step. We express the cause as a past time signal temporal logic (ptSTL) formula and present an efficient monotonicity-based method to synthesize a ptSTL formula from a labeled dataset. Then, in the third step, we modify the faulty system by removing all behaviors that satisfy the ptSTL formula representing the cause of the fault. We apply the framework to two rich modeling formalisms: discrete-time dynamical systems and timed automata. For both of them, we define repairable formulae, the corresponding repair procedures, and illustrate them over case studies.

Secure and private computations over random access machine (RAM) are preferred over computations with circuits or Turing machines. Secure RAM executions become more and more important in the scope of avoiding information leakage when executing programs over a single computer, as well as the clouds. In this paper, we proposed a novel scheme for evaluating RAM programs without revealing any information on the computation, including the program, the data, and the result. We use Shamir Secret Sharing to share all the program instructions and the private string matching technique to ensure the execution of the right instruction sequence. We stress that our scheme obtains information-theoretical security and does not rely on any computational hardness assumptions.

This paper introduces the counterpart of strong bisimilarity for labelled transition systems extended with timeout transitions. It supports this concept through a modal characterisation, congruence results for a standard process algebra with recursion, and a complete axiomatisation.

Programs are often subjected to significant optimizing and parallelizing transformations based on extensive dependence analysis. Formal validation of such transformations needs modelling paradigms which can capture both control and data dependences in the program vividly. Being value-based with an inherent scope of capturing parallelism, the untimed coloured Petri net (CPN) models, reported in the literature, fit the bill well; accordingly, they are likely to be more convenient as the intermediate representations (IRs) of both the source and the transformed codes for translation validation than strictly sequential variable-based IRs like sequential control flow graphs (CFGs). In this work, an efficient path-based equivalence checking method for CPN models of programs on integers is presented. Extensive experimentation has been carried out on several sequential and parallel examples. Complexity and correctness issues have been treated rigorously for the method.

Given a regular expression $R$ and a string $Q$ the regular expression matching problem is to determine if $Q$ is a member of the language generated by $R$. The classic textbook algorithm by Thompson [C. ACM 1968] constructs and simulates a non-deterministic finite automaton in $O(nm)$ time and $O(m)$ space, where $n$ and $m$ are the lengths of the string and the regular expression, respectively. Assuming the strong exponential time hypothesis Backurs and Indyk [FOCS 2016] showed that this result is nearly optimal. However, for most applications determining membership is insufficient and we need to compute \emph{how we match}, i.e., to identify or replace matches or submatches in the string. Using backtracking we can extend Thompson's algorithm to solve this problem, called regular expression parsing, in the same asymptotic time but with a blow up in space to $\Omega(nm)$. Surprisingly, all existing approaches suffer the same or a similar quadratic blow up in space and no known solutions for regular expression parsing significantly improve this gap between matching and parsing. In this paper, we overcome this gap and present a new algorithm for regular expression parsing using $O(nm)$ time and $O(n + m)$ space. To achieve our result, we develop a novel divide and conquer approach similar in spirit to the classic divide and conquer technique by Hirshberg [C. ACM 1975] for computing a longest common subsequence of two strings in quadratic time and linear space. We show how to carefully decompose the problem to handle cyclic interactions in the automaton leading to a subproblem construction of independent interest. Finally, we generalize our techniques to convert other existing state-set transition algorithms for matching to parsing using only linear space.

Let K and L be two languages over $$\Sigma$$ and $$\Gamma$$ (with $$\Gamma \subset \Sigma$$), respectively. Then, the L-reduction of K, denoted by $$K\%\,L$$, is defined by $$\{ u_0u_1\cdots u_n \in (\Sigma - \Gamma )^* \mid u_0v_1u_1 \cdots v_nu_n \in K, \ v_i \in L \ (1\le i \le n) \}$$. This is extended to language classes as follows: $${\mathcal {K}}\% {\mathcal {L}}=\{K\%L \mid K \in {\mathcal {K}}, \, L \in {\mathcal {L}} \}$$. In this paper, we investigate the computing powers of $$\mathcal {K}\%\,\mathcal {L}$$ in which $$\mathcal {K}$$ ranges among various classes of $$\mathcal {INS}^i_{\!\!j}$$ and min-$$\mathcal {LIN}$$, while $$\mathcal {L}$$ is taken as $$\mathcal {DYCK}$$ and $$\mathcal {F}$$, where $$\mathcal {INS}^i_{\!\!j}$$: the class of insertion languages of weight (j, i), min-$$\mathcal {LIN}$$: the class of minimal linear languages, $$\mathcal {DYCK}$$: the class of Dyck languages, and $$\mathcal {F}$$: the class of finite languages. The obtained results include: $$\mathcal {INS}^1_1\,\%\,\mathcal {DYCK}=\mathcal {RE}$$ $$\mathcal {INS}^0_i\,\%\,\mathcal {F}= \mathcal {INS}^1_j\,\%\,\mathcal {F}=\mathcal {CF}$$ (for $$i\ge 3$$ and $$j\ge 1$$) $$\mathcal {INS}^0_2\,\%\,\mathcal {DYCK}=\mathcal {INS}^0_2$$ min-$$\mathcal {LIN}\,\%\,\mathcal {F}_1=\mathcal {LIN}$$ where $$\mathcal {RE}$$, $$\mathcal {CF}$$, $$\mathcal {LIN}$$, $$\mathcal {F}_1$$ are classes of recursively enumerable, of context-free, of linear languages, and of singleton languages over unary alphabet, respectively. Further, we provide a very simple alternative proof for the known result min-$$\mathcal {LIN}\,\%\,\mathcal {DYCK}_2=\mathcal {RE}$$. We also show that with a certain condition, for the class of context-sensitive languages $$\mathcal {CS}$$, there exists no $$\mathcal {K}$$ such that $$\mathcal {K}\%\,\mathcal {DYCK}=\mathcal {CS}$$, which is in marked contrast to the characterization results mentioned above for other classes in Chomsky hierarchy. It should be remarked from the viewpoint of molecular computing theory that the notion of L-reduction is naturally motivated by a molecular biological functioning well-known as RNA splicing occurring in most eukaryotic genes.

The minimum status (or its normalized version called proximity) is a well-known concept in communication network theory. We determine the trees minimizing the minimum status among trees with a given degree sequence, and we show that the trees maximizing the minimum status among trees with a given degree sequence must be caterpillars with specific properties.

Huang and Wong (Acta Inform 21(1):113–123, 1984) proposed a polynomial-time dynamic-programming algorithm for computing optimal generalized binary split trees. We show that their algorithm is incorrect. Thus, it remains open whether such trees can be computed in polynomial time. Spuler (Optimal search trees using two-way key comparisons, PhD thesis, 1994) proposed modifying Huang and Wong’s algorithm to obtain an algorithm for a different problem: computing optimal two-way comparison search trees. We show that the dynamic program underlying Spuler’s algorithm is not valid, in that it does not satisfy the necessary optimal-substructure property and its proposed recurrence relation is incorrect. It remains unknown whether the algorithm is guaranteed to compute a correct overall solution.

We investigate finite automata whose state graphs are undirected. This means that for any transition from state p to q consuming some letter a from the input there exists a symmetric transition from state q to p consuming a letter a as well. So, the corresponding language families are subregular, and in particular in the deterministic case, subreversible. In detail, we study the operational descriptional complexity of deterministic and nondeterministic undirected finite automata. To this end, the different types of automata on alphabets with few letters are characterized. Then, the operational state complexity of the Boolean operations as well as the operations concatenation and iteration is investigated, where tight upper and lower bounds are derived for unary as well as arbitrary alphabets under the condition that the corresponding language classes are closed under the operation considered.

Specifying budgets and deadlines using a process algebra like CSP requires an explicit notion of time. The tock -CSP encoding embeds a rich and flexible approach for modelling discrete-time behaviours with powerful tool support. It uses an event tock , interpreted to mark passage of time. Analysis, however, has traditionally used the standard semantics of CSP, which is inadequate for reasoning about timed refinement. The most recent version of the model checker FDR provides tailored support for tock -CSP, including specific operators, but the standard semantics remains inadequate. In this paper, we characterise tock -CSP as a language in its own right, rich enough to model budgets and deadlines, and reason about Zeno behaviour. We present the first sound tailored semantic model for tock -CSP that captures timewise refinement. It is fully mechanised in Isabelle/HOL and, to enable use of FDR4 to check refinement in this novel model, we use model shifting, which is a technique that explicitly encodes refusals in traces.

Session-based concurrency is a type-based approach to the analysis of message-passing programs. These programs may be specified in an operational or declarative style: the former defines how interactions are properly structured; the latter defines governing conditions for correct interactions. In this paper, we study rigorous relationships between operational and declarative models of session-based concurrency. We develop a correct encoding of session $$\pi$$ π -calculus processes into the linear concurrent constraint calculus ( $$\texttt {lcc}$$ lcc ), a declarative model of concurrency based on partial information (constraints). We exploit session types to ensure that our encoding satisfies precise correctness properties and that it offers a sound basis on which operational and declarative requirements can be jointly specified and reasoned about. We demonstrate the applicability of our results by using our encoding in the specification of realistic communication patterns with time and contextual information.

Algorithms and protocols with time dependent behavior are often specified formally using timed automata. For practical real-time systems, besides real-valued clock variables, these specifications typically contain discrete data variables with nontrivial data flow. In this paper, we propose a configurable lazy abstraction framework for the location reachability problem of timed automata that potentially contain discrete variables. Moreover, based on our previous work, we uniformly formalize in our framework several abstraction refinement strategies for both clock and discrete variables that can be freely combined, resulting in many distinct algorithm configurations. Besides the proposed refinement strategies, the configurability of the framework allows the integration of existing efficient lazy abstraction algorithms for clock variables based on LU\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$${\textit{LU}}$$\end{document}-bounds. We demonstrate the applicability of the framework and the proposed refinement strategies by an empirical evaluation on a wide range of timed automata models, including ones that contain discrete variables or diagonal constraints.

Jumping finite automata and sensing 5′→3′\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$5'\rightarrow 3'$$\end{document} Watson–Crick finite automata are finite-state models of computation which allow to process the input word not only in the strictly left-to-right manner. In this paper a new combined model of them is presented. The accepting power of the new model is studied and compared with the original models and also other well-known language families. Furthermore, the paper investigates changes in the accepting power when commonly studied restrictions from Watson–Crick finite automata, e.g., all states are final, are applied to this combined model. In the end, the paper presents a comprehensive hierarchy of all related language families.

For each two-way alternating finite automaton (afa) A with s states, we directly build a afa Ac\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$A^c$$\end{document} with O(s6)\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$O(s^6)$$\end{document} states which accepts exactly those inputs that are not accepted by A. This improves upon the previously best-known construction, which was both more expensive and more complicated, as it required O(s7)\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$O(s^7)$$\end{document} states and involved building and simulating an intermediate linear-bounded automaton.

Biclustering is a two-dimensional data analysis technique that, applied to a matrix, searches for a subset of rows and columns that intersect to produce a submatrix with given, expected features. Such an approach requires different methods to those of typical classification or regression tasks. In recent years it has become possible to express biclustering goals in the form of Boolean reasoning. This paper presents a new, heuristic approach to bicluster induction in binary data.

For each two-way alternating finite automaton (2AFA) A with s states, we directly build a 2AFA A^c with O(s^6) states which accepts exactly those inputs that are not accepted by A. This improves upon the previously best known construction, which was both more expensive and more complicated, as it required O(s^7) states and involved building and simulating an intermediate linear-bounded automaton.

Transforming ω\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\omega$$\end{document}-automata into parity automata is traditionally done using appearance records. We present an efficient variant of this idea, tailored to Rabin automata, and several optimizations applicable to all appearance records. We compare the methods experimentally and show that our method produces significantly smaller automata than previous approaches.

Constrained reachability is a kind of quantitative path property, which is generally specified by multiphase until formulas originated in continuous stochastic logic. In this paper, through proposing a positive operator valued measure on the set of infinite paths, we develop an exact method to solve the constrained reachability problem for quantum Markov chains. The convergence rate of the reachability is also obtained. We then analyse the complexity of the proposed method, which turns out to be in polynomial-time w.r.t. the size of the classical state space and the dimension of the accompanied Hilbert space. Finally, our method is implemented and applied to a simple quantum protocol.

There has been a recent growth of interest in software engineering community to use grammatical inference, aka automaton learning, in software engineering applications. This is primarily due to the reason that capacity of underlying hardware resources has improved significantly over the last years; which has enabled the use of this approach beyond the toy examples in a greater frequency. In this paper, we present a new grammatical inference algorithm, DKL, to learn deterministic Kripke structures. The DKL is only the second of its kind for incremental learning of deterministic Kripke structures. Earlier, IKL algorithm was introduced for learning deterministic Kripke structures but it often constructs a hypothesis much larger in state size than the target Kripke structure. This problem is known as state-space explosion and it primarily occurs due to the sub-direct product construction used in the IKL design, which in turn affects time efficiency of IKL; especially when it is used for practical applications of software engineering. The DKL algorithm is designed to resolve the problem of state-space explosion. We give a proof of correctness and termination of the DKL algorithm. We also compared the performance of DKL with IKL by implementing an evaluation framework. Our results show that DKL is more efficient in terms of time in reaching the target automaton than the IKL algorithm and is not prone to the problem of state-space explosion.

The overall aim of our research is to develop techniques to reason about the equilibrium properties of multi-agent systems. We model multi-agent systems as concurrent games, in which each player is a process that is assumed to act independently and strategically in pursuit of personal preferences. In this article, we study these games in the context of finite-memory strategies, and we assume players’ preferences are defined by a qualitative and a quantitative objective, which are related by a lexicographic order: a player first prefers to satisfy its qualitative objective (given as a formula of linear temporal logic) and then prefers to minimise costs (given by a mean-payoff function). Our main result is that deciding the existence of a strict $$\epsilon$$ Nash equilibrium in such games is 2ExpTime-complete (and hence decidable), even if players’ deviations are implemented as infinite-memory strategies.

In this paper, we investigate a bitopological duality for algebras of Fitting’s multi-valued logic. We also extend the natural duality theory for ISPI(L)\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\mathbb {ISP_I}(\mathcal {L})$$\end{document} by developing a duality for ISP(L)\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\mathbb {ISP}(\mathcal {L})$$\end{document}, where L\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\mathcal {L}$$\end{document} is a finite algebra in which underlying lattice is bounded distributive.

BPP nets, a subclass of finite Place/Transition Petri nets, are equipped with an efficiently decidable, truly concurrent, bisimulation-based, behavioral equivalence, called team bisimilarity. This equivalence is a very intuitive extension of classic bisimulation equivalence (over labeled transition systems) to BPP nets and it is checked in a distributed manner, without necessarily building a global model of the overall behavior of the marked BPP net. An associated distributed modal logic, called team modal logic (TML, for short), is presented and shown to be coherent with team bisimilarity: two markings are team bisimilar if and only if they satisfy the same TML formulae. As the process algebra BPP (with guarded summation and guarded body of constants) is expressive enough to represent all and only the BPP nets, we provide algebraic laws for team bisimilarity as well as a finite, sound and complete, axiomatization.

The possible interactions between a controller and its environment can naturally be modelled as the arena of a two-player game, and adding an appropriate winning condition permits to specify desirable behavior. The classical model here is the positional game, where both players can (fully or partially) observe the current position in the game graph, which in turn is indicative of their mutual current states. In practice, neither sensing and actuating the environment through physical devices nor data forwarding to and from the controller and signal processing in the controller are instantaneous. The resultant delays force the controller to draw decisions before being aware of the recent history of a play and to submit these decisions well before they can take effect asynchronously. It is known that existence of a winning strategy for the controller in games with such delays is decidable over finite game graphs and with respect to $$\omega$$-regular objectives. The underlying reduction, however, is impractical for non-trivial delays as it incurs a blow-up of the game graph which is exponential in the magnitude of the delay. For safety objectives, we propose a more practical incremental algorithm successively synthesizing a series of controllers handling increasing delays and reducing the game-graph size in between. It is demonstrated using benchmark examples that even a simplistic explicit-state implementation of this algorithm outperforms state-of-the-art symbolic synthesis algorithms as soon as non-trivial delays have to be handled. We furthermore address the practically relevant cases of non-order-preserving delays and bounded message loss, as arising in actual networked control, thereby considerably extending the scope of regular game theory under delay.

We consider the problem of converting a two-way alternating finite automaton (2AFA) with n states to a 2AFA accepting the complement of its language. Complementing is trivial for halting 2AFAs, by swapping the roles of existential and universal decisions and the roles of accepting and rejecting states. However, since 2AFAs do not have resources to detect infinite loops by counting executed steps, it was not known whether the cost of complementing is polynomial in n in the general case. Here we shall show that 2AFAs can be complemented by using O(n^7) states.

Interface theories based on Interface Automata (IA) are formalisms for the component-based specification of concurrent systems. Extensions of their basic synchronization mechanism permit the modelling of data, but are studied in more complex settings involving modal transition systems or do not abstract from internal computation. In this article, we show how de Alfaro and Henzinger’s original IA theory can be conservatively extended by shared memory data, without sacrificing simplicity or imposing restrictions. Our extension IA for shared Memory (IAM) decorates transitions with pre- and post-conditions over algebraic expressions on shared variables, which are taken into account by IA’s notion of component compatibility. Simplicity is preserved as IAM can be embedded into IA and, thus, accurately lifts IA’s compatibility concept to shared memory. We also provide a ground semantics for IAM that demonstrates that our abstract handling of data within IA’s open systems view is faithful to the standard treatment of data in closed systems.

A reversible Turing machine (RTM) is a standard model of reversible computing that reflects physical reversibility. So far, to describe an RTM the quadruple formulation and the quintuple formulation have been used. In this paper, we propose the program form as a new formulation for RTMs. There, an RTM is described by a sequence of only five kinds of instructions. It is shown that any RTM in the quintuple form is converted to an RTM in the program form, and vice versa. We also show each instruction is implemented by a particular reversible logic element with memory called a rotary element (RE) very simply. Hence, a circuit that simulates a given RTM is easily and systematically constructed out of REs.

There are two types of stateless deterministic ordered restarting automata that both characterize the class of regular languages: the stl-det-ORWW-automaton and the stl-det-ORRWW-automaton. For the former a notion of reversibility has been introduced and studied that is very much tuned to the way in which restarting automata work. Here we suggest another, more classical, notion of reversibility for stl-det-ORRWW-automata, and we show that each regular language is accepted by such a reversible stl-det-ORRWW-automaton. We study the descriptional complexity of these automata, showing that they are exponentially more succinct than nondeterministic finite-state acceptors. We also look at the case of unary input alphabets.

A synchronization problem in cellular automata has been known as the Firing Squad Synchronization Problem (FSSP), where the FSSP gives a finite-state protocol for synchronizing a large scale of cellular automata. A quest for smaller state FSSP solutions has been an interesting problem for a long time. It has been shown by Balzer (Inf Control 10:22–42, 1967), Sanders (in: Jesshope, Jossifov, Wilhelmi (eds) Proceedings of the VI international workshop on parallel processing by cellular automata and arrays, Akademie, Berlin, 1994) and Berthiaume et al. (Theoret Comput Sci 320:213–228, 2004) that there exists no 4-state FSSP solution in arrays and rings. The number four is the state lower bound in the class of FSSP protocols. Umeo et al. (Parallel Process Lett 19(2):299–313, 2009), by introducing a concept of full versus partial FSSP solutions, provided a list of the smallest 4-state symmetric powers-of-2 FSSP protocols that can synchronize any one-dimensional (1D) ring cellular automata of length $$n=2^{k}$$ for any positive integer $$k \ge 1$$. Afterwards, Ng (in: Partial solutions for the firing squad synchronization problem on rings, ProQuest Publications, Ann Arbor, MI, 2011) also added a list of asymmetric FSSP partial solutions, thus completing the 4-state powers-of-2 FSSP partial solutions. A question whether there are any 4-state partial solutions for ring lengths other than powers-of-2 has remained open. In this paper, we answer the question by providing a new class of the smallest symmetric and asymmetric 4-state FSSP protocols that can synchronize any 1D ring of length $$n=2^{k}-1$$ for any positive integer $$k \ge 2$$. We show that the class includes a rich variety of FSSP protocols that consists of 39 symmetric and 132 asymmetric solutions, ranging from minimum to linear synchronization time. In addition, we make an investigation into several interesting properties of those partial solutions, such as swapping general states, transposed protocols, a duality property between them, and an inclusive property of powers-of-2 solutions.

Top-cited authors
• Leiden University
• SRI International
• King's College London
• Masaryk University
• Uppsala University