A Generic Program Slicing Technique Based on Language Definitions

Formal pattern languages are used in industry to communicate and analyse requirements, as they are said to be both machine-readable and intuitively understandable for humans. The questions arise to what extent this intuitive understanding of a pattern language is in agreement with its formal semantics and whether this understanding can be increased systematically. We present two consecutive empirical experiments to address these questions. The formal semantics serves as an objective judge on the intuitive understanding. Our experiments confirm the practical usefulness of HanforPL insofar the intuition matches the formal semantics in most practically relevant cases. They also reveal a number of edge cases where even a prior exposure to formal logic is not a guarantee for correct understanding. We present and validate systematic adjustments to the patterns, leading to several large increases in understandability but come at the cost of new, but less impactful ambiguities. We demonstrate how an inquiry on the alignment of the intuitive and formal semantics of a pattern language can help to understand and improve the language. While results regarding the understandability of HanforPL are favourable in commonly used cases, there is potential for improvement. The systematic adaption of patterns shows that small modifications may have large effects on the alignment of formal and intuitive semantics, and that modification must be considered with caution in the context of the respective pattern to avoid unintentionally adding new ambiguities. This article is an extension of our published REFSQ paper.

The main aim of this work is to evaluate whether Boolos’ semantics for second-order languages is model-theoretically equivalent to standard model-theoretic semantics. Such an equivalence result is, actually, directly proved in the “Appendix”. I argue that Boolos’ intent in developing such a semantics is not to avoid set-theoretic notions in favor of pluralities. It is, rather, to prevent that predicates, in the sense of functions, refer to classes of classes. Boolos’ formal semantics differs from a semantics of pluralities for Boolos’ plural reading of second-order quantifiers, for the notion of plurality is much more general, not only of that set, but also of class. In fact, by showing that a plurality is equivalent to sub-sets of a power set, the notion of plurality comes to suffer a loss of generality. Despite of this equivalence result, I maintain that Boolos’ formal semantics does not committ (directly) second-order languages (theories) to second-order entities (and to set theory), contrary to standard semantics. Further, such an equivalence result provides a rationale for many criticisms to Boolos’ formal semantics, in particular those by Resnik and Parsons against its alleged ontological innocence and on its Platonistic presupposition. The key set-theoretic notion involved in the equivalence proof is that of many-valued function. But, first, I will provide a clarification of the philosophical context and theoretical grounds of the genesis of Boolos’ formal semantics.

UDL/I is a hardware design language for ASIC design developed in a Japanese LSI design language standardization project. A formal semantics of UDL/I is presented. There is no established way to define semantics of hardware design languages, because there is no general computation model for them. A definition method of formal semantics for UDL/I and semantics suitable for a standard language are developed. The basic idea is that the semantics of the language should be defined independently of simulators. The language provides an abstract model of hardware. The role of the language designer is to provide an abstract model of hardware which is natural and general for hardware designers and CAD engineers. The authors introduce a novel behavior model of hardware and define the semantics with a nondeterministic feature. >

Reaction Systems (RSs) are a successful computational framework for modeling systems inspired by biochemistry. An RS defines a set of rules (reactions) over a finite set of entities (e.g., molecules, proteins, genes, etc.). A computation in this system is performed by rewriting a finite set of entities (a computation state) using all the enabled reactions in the RS, thereby producing a new set of entities (a new computation state). The number of entities in the reactions and in the computation states can be large, making the analysis of RS behavior difficult without a proper automated support. In this paper, we use the Maude language—a programming language based on rewriting logic—to define a formal executable semantics for RSs, which can be used to precisely simulate the system behavior as well as to perform reachability analysis over the system computation space. Then, by enriching the proposed semantics, we formalize a forward slicer algorithm for RSs that allows us to observe the evolution of the system on both the initial input and a fragment of it (the slicing criterion), thus facilitating the detection of forward causality and influence relations due to the absence/presence of some entities in the slicing criterion. The pursued approach is illustrated by a biological reaction system that models a gene regulation network for controlling the process of differentiation of T helper lymphocytes.

Program slicing is a well-known program analysis technique that extracts the elements of a program related to a particular computation. Based on modular monadic semantics of a programming language, this paper presents a new formal method for slicing, called modular monadic slicing, by abstracting the computation of slicing as a slice monad transformer. With the use of slice transformer, the feature of program slicing can be combined in a modular way into semantic descriptions of the program analyzed. According to these, this paper gives both monadic dynamic and static slicing algorithms. They compute program slices directly on abstract syntax, without the needs to explicitly construct intermediate structures such as dependence graphs, or to record an execution history in dynamic slicing algorithm.

The programming language ALGOL 60 has been used to illustrate several different styles of formal semantic description. This paper identifies the main challenges in providing formal semantics for imperative programming languages and reviews the responses to these challenges in four relatively complete formal descriptions of ALGOL 60. The aim is to identify the key concepts rather than become distracted by the minutiae of notational conventions adopted by their authors. This paper also explores the historical reasons for the development of these descriptions in particular, and gives some general historical background of the groups involved (the IBM laboratories in Vienna and Hursley, and Oxford’s Programming Research Group).

This paper proposes a method to formalize semantics. It makes the formal semantics more harmonious with compilation. This method is established on the basis of a temporal logic language, which is, on the one hand, a logic system, so its semantics is simple and easy to formalize and convenient to implement; on the other hand, an intermediate programming language, so the semantics of other higher languages can be mapped into it by means of rigorous transformation. To organize a kind of 2-1evel formal semantics in this way the compilation is constituted.

Semantic change detection (SCD) represents a challenging task in the interpretation of remote sensing images (RSIs), with the goal of identifying change regions and extracting semantic information from bitemporal RSIs simultaneously. The recent integration of deep neural networks leveraging multitask learning has shown promise in enhancing SCD performance. However, there is still a challenge in improving SCD performance, specifically in designing a fine-grained network structure that can handle the two subtasks of change region localization and semantic information recognition in parallel. In this context, a novel multitask Siamese network, termed EGMS-Net, is proposed to boost the performance of SCD, which consists of three core components. First, a coarse-to-fine multitask Siamese network is constructed to obtain semantic information and change information at multiple levels. Second, an adaptive change information enhancement method based on spatial-spectral collaborative attention mechanism is proposed, which can assist the accurate localization of change regions without significantly increasing the model parameters. Third, a change information guidance module is developed to strengthen the interaction between multitask branches and reduce the difficulty of network training. Experiments on three benchmark datasets demonstrate that the proposed EGMS-Net outperforms existing state-of-the-art methods in the SCD community.

Formally verifying functional and security properties of a large-scale production operating system is highly desirable. However, it is challenging as such OSes are often written in multiple source languages that have no formal semantics - a prerequisite for formal reasoning. To avoid expensive formalization of the semantics of multiple high-level source languages, we present a lightweight and rigorous verification toolchain that verifies OS code at the binary level, targeting ARM machines. To reason about ARM instructions, we first translate the ARM Specification Language that describes the semantics of the ARMv8 ISA into the PVS7 theorem prover and verify the translation. We leverage the radare2 reverse engineering tool to decode ARM binaries into PVS7 and verify the translation. Our translation verification methodology is a lightweight formal validation technique that generates large-scale instruction emulation test lemmas whose proof obligations are automatically discharged. To demonstrate our verification methodology, we apply the technique on two OSes: Google's Zircon and a subset of Linux. We extract a set of 370 functions from these OSes, translate them into PVS7, and verify the correctness of the translation by automatically discharging hundreds of thousands of proof obligations and tests. This took 27.5 person-months to develop.

The abrupt onset of objects often involuntarily captures attention (J. Jonides & S. Yantis, 1988) and the eyes (J. Theeuwes, A. F. Kramer, S. Hahn, & D. Irwin, 1998). The new-object hypothesis proposes that the appearance of something new (new semantic and structural information and/or spatiotemporal newness), not the accompanying low-level perceptual transients, causes an involuntary reorienting of attention (S. Yantis & A. P. Hillstrom, 1994). We investigated whether semantic and structural changes alone are sufficient to capture the eyes as strongly as abrupt onsets do. Observers moved their eyes to a target object while another object either onset or smoothly and quickly morphed. If semantic and structural changes are sufficient to capture the eyes, morphs should capture the eyes as strongly as onsets do. Results show that morphs were not fixated first as often as onsets. These findings indicate that new semantic and structural information alone is far less effective at capturing the eyes as onsets.

This paper shows a way of defining the formal semantics of computer languages in the military application domain (BMLs - Battle Management Languages). In our approach we show a way how to adapt natural semantics known as a means of defining formal semantics in the area of general- purpose programming languages to BMLs. By using formal semantics, the mathematical model of BML is created and BML language constructions is assigned unambiguous meaning.

Objectives: Program Slicing is proved in breaking down the large program into the small relevant parts that is needed as per the specified criteria. The Objective of this paper is the betterment of existing program slicing techniques. Method/Statistical Analysis: Methodology is proposed to start slicing the software from designing level and continue it with source code level. Mingling of the program slicing with UML model slicing is done by applying the program slicing technique to code related to the remaining relevant model that is extracted from the large software architecture model at design level. Flowchart is presented with the steps proposed in the methodology. Findings: Using a case study it is concluded that the complexity of the complete software cycle is reduced as compared to the complexity of program slicing if applied directly to the code. Application/Improvements: Fault localization is taken as a single application, other applications like improvement in the changeability and reusability of source codes can be added.

Elements of Formal Semantics (EFS) has already been reviewed twice (Rett in Glossa 1(1):42, 2016; Erlewine in Comput Linguist 42(4):837–839, 2017). As well, the website for the work is accompanied by evaluative quotes by noted scholars. All are very positive concerning its clarity and its utility as an introduction to formal semantics for natural language. As I agree with these evaluations my interest in reiterating them in slightly different words is limited. So my reviews of the content chapters will be accompanied by a Reflections section consisting of my own reflections on the foundations of model theoretic semantics for natural language as laid out in EFS. The issues I address—alternate ways of accomplishing the tasks Winter treats—should not be included in an introductory work but they may be helpful for those who teach classes for which EFS is an appropriate text. They might also help with queries about the content of the text by those using it. I note that a mark of a clear text is that it allows the reader to reflect on its content not its presentation.

Isabelle is a generic meta-logical framework for implementing logical formalisms, and Isabelle/HOL is the specialization of Isabelle for HOL, which stands for Higher Order Logic. In programming language theory, formal semantics is the field concerned with the rigorous mathematical study of the meaning of programming languages. In this paper we develop a relational denotational semantics for a small imperative programming language and implement it as a theory in Isabelle/HOL. We give special attention to the specification of monotonic fix point functional for loops and provide non-trivial proofs of interesting lemmas and properties with the structured proof language Isar.

A System of Systems (SoS), composed of independent constituent systems, can create synergy among its systems to achieve a common goal. Many studies have used statistical model checking techniques to verify how well an SoS can achieve its goals. SoS models are usually complex and probabilistic, which makes statistical verification computationally expensive. To reduce this cost, dynamic slicing techniques can be applied to SoS models since both dynamic slicing and statistical verification focus on the models' execution samples. However, existing dynamic slicing techniques cannot guarantee executable accurate slices of SoS models when the models contain uncertainty. Therefore, we propose a hybrid slicing approach that combines dynamic backward slicing and modified observation-based slicing to produce accurate executable slices. Experimentation on the proposed technique found that the verification time was significantly reduced (47--56%), depending on the property, while preserving the verification results.