Introducing complexity to formal testing J. Log. Algebr. Methods Program. (IF 0.632) Pub Date : 2019-10-31 Ismael Rodríguez; Fernando Rosa-Velardo; Fernando Rubio
A general theory introducing asymptotic complexity to testing is presented. Our goal is measuring how fast the effort of testing must increase to reach higher levels of partial certainty on the correctness of the implementation under test (IUT). By recent works it is known that, for many practical testing scenarios, any partial level of correctness certainty less than 1 (where 1 means full certainty) can be reached by some finite test suite. In this paper we address the problem of finding out how fast must these test suites grow as long as the target level gets closer to 1. More precisely, we want to study how test suites grow with α, where α is the inverse of the distance to 1 (e.g., if α=4 then our target level is 0.75=1−14). A general theory to measure this testing complexity is developed. We use this theory to analyze the testing complexity of some general testing problems, as well as the complexity of some specific testing strategies for these problems, and discover that they are within e.g., O(logα), O(log2α), O(α), O(αlogα), or O(α). Similarly as the computational complexity theory conceptually distinguishes between the complexity of problems and algorithms, tightly identifying the complexity of a testing problem will require reasoning about any testing strategy for the problem. The capability to identify testing complexities will provide testers with a measure of the productivity of testing, that is, a measure of the utility of applying the (n+1)-th planned test case (after having passed the n previous ones) in terms of how closer would that additional test case get us to the (ideal) complete certainty on the IUT (in-)correctness.
Ground confluence of order-sorted conditional specifications modulo axioms J. Log. Algebr. Methods Program. (IF 0.632) Pub Date : 2019-11-26 Francisco Durán; José Meseguer; Camilo Rocha
Terminating functional programs should be deterministic, i.e., should evaluate to a unique result, regardless of the evaluation order. For equational functional programs such determinism is exactly captured by the ground confluence property. For operationally terminating conditional equations this is equivalent to ground local confluence, which follows from local confluence. Checking local confluence by computing critical pairs is the standard way to check ground confluence . The problem is that some perfectly reasonable equational programs are not locally confluent and it can be very hard or even impossible to make them so by adding more equations. We propose three methods, called Methods 1–3, that can be synergistically combined to prove an order-sorted conditional specification modulo axioms B ground locally confluent. Method 1 applies the strategy proposed in  to use non-joinable critical pairs as completion hints to either achieve local confluence or reduce the number of critical pairs. Method 2 uses the inductive joinability inference system proposed in this paper to try to prove the critical pairs remaining after applying Method 1 ground joinable. It can furthermore show ground local confluence of the original specification. Method 3 is hierarchical in nature: it can be used to prove the ground local confluence of a conditional equational specification whose conditions belong to a subspecification that has already been proved ground confluent and operationally terminating, and that is conservatively extended by the overall specification in an appropriate sense. These methods apply to order-sorted and possibly conditional equational programs modulo axioms such as, e.g., Maude functional modules. We show their effectiveness in proving the ground confluence of non-trivial examples that have eluded previous proof attempts.
Determinizing monitors for HML with recursion J. Log. Algebr. Methods Program. (IF 0.632) Pub Date : 2019-12-31 Luca Aceto; Antonis Achilleos; Adrian Francalanza; Anna Ingólfsdóttir; Sævar Örn Kjartansson
We examine the determinization of monitors for HML with recursion. We demonstrate that every monitor is equivalent to a deterministic one, which is at most doubly exponential in size with respect to the original monitor. When monitors are described as CCS-like processes, this doubly exponential bound is optimal. When (deterministic) monitors are described as finite automata (or as their labelled transition systems), then they can be exponentially more succinct than their CCS process form.
Abstracting Models of Strong Normalization for Classical Calculi J. Log. Algebr. Methods Program. (IF 0.632) Pub Date : 2019-12-20 Paul Downen; Philip Johnson-Freyd; Zena M. Ariola
Modern programming languages have effects and mix multiple calling conventions, and their core calculi should too. We characterize calling conventions by their “substitution discipline” that says what variables stand for, and design calculi for mixing disciplines in a single program. Building on variations of the reducibility candidates method, including biorthogonality and symmetric candidates which are both specialized for one discipline, we develop a single uniform framework for strong normalization encompassing call-by-name, call-by-value, call-by-need, call-by-push-value, non-deterministic disciplines, and any others satisfying some simple criteria. We explicate commonalities of previous methods and show they are special cases of the uniform framework and they extend to multi-discipline programs.
A formal approach to the engineering of domain-specific distributed systems J. Log. Algebr. Methods Program. (IF 0.632) Pub Date : 2019-11-26 Rocco De Nicola; Gianluigi Ferrari; Rosario Pugliese; Francesco Tiezzi
We review some results regarding specification, programming and verification of different classes of distributed systems which stemmed from the research of the Concurrency and Mobility Group at University of Firenze. More specifically, we examine the distinguishing features of network-aware programming, service-oriented computing, autonomic computing, and collective adaptive systems programming. We then present an overview of four different languages, namely Klaim, Cows, Scel and AbC. For each language, we discuss design choices, present syntax and semantics, show how the different formalisms can be used to model and program a travel booking scenario, and describe programming environments and verification techniques.