Journal of Logical and Algebraic Methods in Programming最新文献

Stormwater detention ponds play an important role in urban water management for collecting and conveying rainfall runoff from urban catchment areas to nearby streams. Their purpose is not only to avoid flooding but also to reduce stream erosion and degradation caused by the direct discharge of pollutants to the stream. We model the problem of controlling the discharge rate of water from the ponds as a partially observable hybrid Markov decision process and subsequently use Uppaal Stratego for synthesizing safe and near optimal control strategies. The generated strategies are based on noisy sensor measurements of the water height in the pond, hence the underlying system is only partially observable. We present results analyzing how sensitive the synthesized strategies are with respect to the accuracy of the measurement sensors in both offline and online settings. These types of analyses not only provide insight into the robustness of the generated strategies, but they can also be used for deciding on which measurement sensors to use, thereby balancing sensor cost and accuracy.

In his book A practical theory of programming [10], [12], Eric Hehner proposes and applies a radical reformulation of set theory in which the collection and packaging of elements are seen as separate activities. This provides for unpackaged collections, referred to as “bunches”. Bunches allow us to reason about non-determinism at the level of terms, and, very remarkably, allow us to reason about the conceptual entity “nothing”, which is just an empty bunch (and very different from an empty set). This eliminates mathematical “gaps” caused by undefined terms. We have made use of bunches in a number of papers that develop a refinement calculus for backtracking programs. We formulate our bunch theory as an extension of the set theory used in the B-Method, and provide a denotational model to give this formulation a sound mathematical basis. We replace the classical logic that underpins B with a version that is still able to prove the laws of our logic toolkit, but is unable to prove the property, derivable in classical logic, that every term denotes an element, which for us is pathological since we hold that terms such as 1/0 simply denote “nothing”. This change facilitates our ability to reason about partial functions and backtracking programs. We include a section on our backtracking program calculus, showing how it is derived from WP and how bunch theory simplifies its formulation. We illustrate its use with two small case studies.

We discuss two extensions to a recently introduced theory of arrays, which are based on considerations coming from the model theory of power structures. First, we discuss how the ordering relation on the index set can be expressed succinctly by referring to arbitrary Venn regions. Second, we show how to add general aggregators to the calculus. The result is a logic that subsumes four previous fragments discussed in the literature and is distinct from array fold logic, in that it can express summations, while its satisfiability problem remains in non-deterministic polynomial time.

In this paper we study the problem of realizability of reactive specifications written in ${\mathrm{LTL}}_T$, which is the extension of LTL where atomic propositions can be literals from a first-order theory, including arithmetic theories. We present a solution based on transforming ${\mathrm{LTL}}_T$ specifications into purely Boolean specifications by (1) substituting theory literals by Boolean variables, and (2) computing an additional Boolean formula that captures the dependencies between the new variables imposed by the literals. We prove that the resulting specification is realizable if and only if the original specification is realizable. Moreover, the resulting specification can be passed to existing Boolean off-the-shelf synthesis and realizability tools, which can handle only Boolean LTL specifications.

A second contribution is to prove that ${\mathrm{LTL}}_T$ realizability of theories with a decidable ${\exists }^{⁎}{\forall }^{⁎}$ fragment is decidable for all combinations of LTL temporal modalities. We present a simple version of our method, which relies on SMT solving, and performs a brute-force search to construct the “extra requirement”. A third contribution is an algorithm that checks whether a candidate is a correct Booleanization in non-Boolean LTL realizability.

Binary multirelations allow modelling alternating nondeterminism, for instance, in games or nondeterministically evolving systems interacting with an environment. Such systems can show partial or total functional behaviour at both levels of alternation, so that nondeterministic behaviour may occur only at one level or both levels, or not at all. We study classes of inner and outer partial and total functional multirelations in a multirelational language based on relation algebra and power allegories. While it is known that general multirelations do not form a category, we show in the multirelational language that the classes of deterministic multirelations mentioned form categories with respect to Peleg composition from concurrent dynamic logic, and sometimes quantaloids. Some of these categories are isomorphic to the category of binary relations. We also introduce determinisation maps that approximate multirelations either by binary relations or by deterministic multirelations. Such maps are useful for defining modal operators on multirelations.

We generalise the distribution semantics underpinning probabilistic logic programming by distilling its essential concept, the separation of a free random component and a deterministic part. This abstracts the core ideas beyond logic programming as such to encompass frameworks from probabilistic databases, probabilistic finite model theory and discrete lifted Bayesian networks. To demonstrate the usefulness of such a general approach, we completely characterise the projective families of distributions representable in the generalised distribution semantics and we demonstrate both that large classes of interesting projective families cannot be represented in a generalised distribution semantics and that already a very limited fragment of logic programming (acyclic determinate logic programs) in the deterministic part suffices to represent all those projective families that are representable in the generalised distribution semantics at all.

This special issue collects extended versions of selected papers presented at the 20th Workshop on Programming and Languages (PROLE 2021), held as a hybrid event in Málaga from September 22 to 24, 2021.

As robotic applications continue to expand and task complexity increases, the adoption of more advanced and sophisticated control algorithms and models becomes critical. Traditional methods, relying on manual abstraction and modeling to verify these algorithms and models, may not fully encompass all potential design paths, leading to incomplete models, design defects, and increased vulnerability to security risks. The verification of control systems using formal methods is crucial for ensuring the safety of robots. This paper introduces a formal verification framework for robot kinematics implemented in Coq. It constructs a formal proof for the theory of robot motion and control algorithms, specifically focusing on the theory of robot kinematics, which includes the homogeneous representation of robot coordinates and the transformation relations between different coordinate systems. Subsequently, we provide formal definitions and verification for several commonly used structural robots, along with their coordinate transformation algorithms. Finally, we extract the Coq code, convert the functional algorithms into OCaml code, and perform data validation using various examples. It is worth emphasizing that the framework we have built possesses a high level of reusability, providing a solid technological foundation for the development of kinematics theorem libraries.

Cyber-Physical systems (CPS), containing discrete behaviors of the cyber and continuous behaviors of the physical, have gained wide applications in many fields. Since CPS subsume the intersection of cyber systems and physical processes, the traditional modeling languages which merely include discrete variables are no longer applicable to CPS. Accordingly, a shared variable language called CPSL${}^{sc}$ was proposed to specify CPS. In this paper, we elaborate the algebraic semantics for this language, so that every program of CPSL${}^{sc}$ can be converted into a unified form called guarded choice form and the sequentialization of parallel programs is achieved. Additionally, we formalize the algebraic semantics in the rewriting engine Real-Time Maude. With the algebraic laws constructed, for every program specified with CPSL${}^{sc}$, we can simulate its execution step by step. Furthermore, automatic transformation and execution are attained. As a consequence, if the program and its initial data state are provided, the corresponding trace of data states during execution can be generated. In the light of the generated trace, automatic verification can be carried out as well.

Stream processing has inspired new computational approaches to facilitate effectiveness and efficiency. One such approach is the dynamic pipeline, which serves as a powerful computational model for stream processing. It is particularly well suited for solving problems that require incremental generation of results, making it an approach for scenarios where real-time analysis and responsiveness are critical. This paper aims to address a family of problems using the Dynamic Pipeline approach, and as a first step, we provide a comprehensive characterization of this problem family. In addition, we present the definition of a Dynamic Pipeline framework. To demonstrate the practicality of this framework, we present a proof of concept through its implementation and perform an empirical performance study. To this end, we focus on solving the problem of enumerating or listing the weakly connected components of a graph within the proposed framework. We provide two implementations of this algorithm to demonstrate the computational power and continuous behavior of the Dynamic Pipeline framework. The first implementation serves as a baseline for our experiments, representing an ad hoc solution based on the Dynamic Pipeline approach. In contrast, the second implementation is built on top of the developed framework. The observed results strongly support the suitability and effectiveness of the Dynamic Pipeline framework for implementing graph stream processing problems, especially those where continuous and real-time result generation is essential.