Acta Informatica最新文献

Explainability is emerging as a key requirement for autonomous systems. While many works have focused on what constitutes a valid explanation, few have considered formalizing explainability as a system property. In this work, we approach this problem from the perspective of hyperproperties. We start with a combination of three prominent flavors of modal logic and show how they can be used for specifying and verifying counterfactual explainability in multi-agent systems: With Lewis’ counterfactuals, linear-time temporal logic, and a knowledge modality, we can reason about whether agents know why a specific observation occurs, i.e., whether that observation is explainable to them. We use this logic to formalize multiple notions of explainability on the system level. We then show how this logic can be embedded into a hyperlogic. Notably, from this analysis we conclude that the model-checking problem of our logic is decidable, which paves the way for the automated verification of explainability requirements.

Minimum spanning cactus and minimum spanning cactus extension problems on outerplanar graphs are studied. Linear algorithms are presented for both problems on outerplanar graphs. A partitioning technique is introduced that partitions a maximal biconnected outerplanar graph into a set of maximal star-outerplanar subgraphs and some chords. Further, the minimum spanning cacti of these star-outerplanar subgraphs can be computed and suitably combined to get a minimum spanning cactus and a minimum spanning cactus extension of a given outerplanar graph.

Given a deterministic finite automaton (DFA) A, we present a simple algorithm for constructing deterministic finite automata that accept the shortest forbidden factors, the shortest forbidden prefixes, the shortest forbidden suffixes, the shortest forbidden words, the shortest allowed suffixes, and the shortest allowed words of the automaton A. We refer to these sets as the shortest characteristic factors of the automaton A. If the given automaton is local, and therefore the language it accepts is strictly locally testable, the sets of its shortest characteristic factors are finite, and these automata are acyclic. Otherwise, they accept infinite languages. This approach simplifies existing methods for the extraction of forbidden factors, allows the extraction of more types of characteristic factors, and also generalizes the extraction for all classes of DFAs. Furthermore, we demonstrate that this type of extraction can be used for a sublinear run of an automaton for certain inputs. We define a positive position run of a deterministic finite automaton, representing all positions in an input string where the automaton reaches a final state. Finally, we present an algorithm for computing the positive position run of the automaton, which utilizes pattern set matching of its shortest forbidden factors and its shortest forbidden or allowed suffixes, provided that the sets are finite. We showcase the computation of the positive position run of a local automaton using backward pattern set matching, which can achieve sublinear time.

In this paper, we analyze the weighted partial vertex cover problem on undirected, vertex-weighted, edge-weighted trees (WPVCT). This problem has been studied in the literature from the perspectives of exact and approximation algorithms. We investigate this problem from the perspectives of parameterization and kernelization. The WPVCT problem finds applications in a number of domains including communications, logistics and data science. This problem is defined by a number of parameters (input, output and structural). We focus on the number of vertices in the optimal cover as the parameter of interest (output parameter). One of our results is a lower bound for parameterized algorithms for the WPVCT problem. A second result is a lower bound on the number of bits in a kernel for the same problem. Both these results are based on the Exponential Time Hypothesis (ETH).

We analyze integer programming formulations for determining the treewidth of a graph that are based on perfect elimination orderings. For the first time, we prove structural properties that explain their limitations in providing convenient lower bounds and show how the latter are constituted. Moreover, we investigate a flow metric approach that proved promising to achieve approximation guarantees for the pathwidth of a graph, and we show why these techniques cannot be carried over to improve the addressed treewidth formulations. In addition, we present two complementary formulations for treewidth that employ positional rather than relational variables. Via computational experiments, we provide an impression on the quality and proportionality of the lower bounds on the treewidth obtained with different relaxations of perfect elimination ordering formulations.

The SMT (Satisfiability Modulo Theories) theory of arrays is well-established and widely used, with various decision procedures and extensions developed for it. However, recent contributions suggest that developing tailored reasoning for some theories, such as sequences and strings, can be more efficient than reasoning over them through axiomatization over the theory of arrays. In this paper, we are interested in reasoning over (n)-indexed sequences as they are found in some programming languages, such as Ada. We propose an SMT theory of (n)-indexed sequences and explore different ways to represent and reason over (n)-indexed sequences using existing theories, as well as tailored calculi for this theory.

A drawing of a graph is a geometric representation of its vertices and edges. Plane 3-trees have been well studied in graph drawing literature. For many graph drawing styles, the aesthetic qualities achieved for plane 3-trees are much better than the ones known for general plane graphs. This motivates us to investigate whether one can find a large plane 3-tree type structure in a general plane graph, and if so, whether it can be leveraged to obtain a better drawing for the graph. We thus introduce the concept of a 3-tree core H of a 3-connected plane graph G. Here, H is an edge-labeled plane 3-tree that represents G, and the distance d between H and G is the number of vertices of G that are missing in H. As an application of this concept, we consider the planar ortho-path visibility drawing, where each vertex is drawn as an orthogonal polygonal chain on an integer grid and each edge is drawn as an orthogonal line segment between the paths corresponding to its end vertices. We show that if H has a flat visibility drawing (i.e., each ortho-path is a horizontal line segment) with height k, then G has an ortho-path visibility drawing with height (O(k2^d)). In particular, if G is a planar triangulation and not too distant from a 3-tree core, i.e., (d=O(1)), then G can be drawn with height (4n/9+O(1)) by choosing an appropriate planar embedding. This bound is interesting as it is significantly smaller than the lower bound of (2n/3+O(1)) when the ortho-path visibility drawing must respect the input embedding.

HyperLTL model-checking enables the automated verification of information-flow properties for security-critical systems. However, it only provides a binary answer. Here, we consider the problem of computing counterexamples and explanations for HyperLTL model-checking, thereby considerably increasing its usefulness. Based on the maxim “counterexamples/explanations are Skolem functions for the existentially quantified trace variables”, we consider (Turing machine) computable Skolem functions. As not every finite transition system and formula have computable Skolem functions witnessing that the system satisfies the formula, we consider the problem of deciding whether such functions exist. Our main result shows that this problem is decidable by reducing it to solving multiplayer games with hierarchical imperfect information. Furthermore, our algorithm also computes transducers implementing such functions, if they exist.

Enforcement of information-flow policies has been extensively studied by language-based approaches over the past few decades. In this paper, we propose an alternative, novel, general, and effective approach using enforcement of hyperproperties– a powerful formalism for expressing and reasoning about a wide range of information-flow security policies. We study black- vs. gray- vs. white-box enforcement of hyperproperties expressed by nondeterministic finite-word hyperautomata (NFH), where the enforcer has null, some, or complete information about the implementation of the system under scrutiny. Given an NFH, in order to generate a runtime enforcer, we reduce the problem to controller synthesis for hyperproperties and subsequently to the satisfiability problem for quantified Boolean formulas (QBFs). The resulting enforcers are transferable with low-overhead. We conduct a rich set of case studies, including information-flow control for JavaScript code, as well as synthesizing obfuscators for control plants.

When a concrete concurrent object refines another, more abstract object, the correctness of a program employing the concrete object can be verified by considering its behaviors when using the more abstract object. This approach is sound for trace properties of the program, but not for hyperproperties, including many security properties and probability distributions of events. We define strong observational refinement, a strengthening of refinement that preserves hypersafety properties, and prove that it is equivalent to the existence of forward simulations. We show that strong observational refinement generalizes strong linearizability, a restriction of linearizability, the prevalent consistency condition for implementing concurrent objects. Our results imply that strong linearizability is also equivalent to existence of forward simulations, and show that strongly linearizable implementations can be composed both horizontally and vertically. This paper also investigates whether there are wait-free strongly-linearizable implementations from realistic primitives such as test&set or fetch&add, whose consensus number is 2. We show that many objects with consensus number 1 have wait-free strongly-linearizable implementations from fetch&add. We also show that several objects with consensus number 2 have wait-free or lock-free implementations from other objects with consensus number 2. In contrast, we prove that even when fetch&add, swap and test&set primitives are used, some objects with consensus number 2 do not have lock-free strongly-linearizable implementations. This includes queues and stacks, and relaxed variants thereof.