Operational Semantics Research Articles

Полная решающая процедура для теории ограниченной адресной арифметики

The process of developing C programs is quite often prone to errors related to the uses of pointer arithmetic and operations on memory addresses. This promotes a need in developing various tools for automated program verification. One of the techniques frequently employed by those tools is invocation of appropriate decision procedures implemented within existing SMT-solvers. But at the same time both the SMT standard and most existing SMT-solvers lack the relevant logics (combinations of logical theories) for directly and precisely modelling the semantics of pointer operations in C. One of the possible ways to support these logics is to implement them in an SMT solver, but this approach can be time-consuming (as requires modifying the solver’s source code), inflexible (introducing any changes to the theory’s signature or semantics can be unreasonably hard) and limited (every solver has to be supported separately). Another way is to design and implement custom quantifier instantiation strategies. These strategies can be then used to translate formulas in the desired theory combinations to formulas in well-supported decidable logics such as QF_UFLIA. In this paper, we present an instantiation procedure for translating formulas in the theory of bounded pointer arithmetic into the QF_UFLIA logic. We formally proved soundness and completeness of our instantiation procedure in Isabelle/HOL. The paper presents an informal description of this proof of the proposed procedure. The theory of bounded pointer arithmetic itself was formulated based on known errors regarding the correct use of pointer arithmetic operations in industrial code as well as the semantics of these operations specified in the C standard. Similar procedure can also be defined for a practically relevant fragment of the theory of bit vectors (monotone propositional combinations of equalities between bitwise expressions). Our approach is sufficient to obtain efficient decision procedures implemented as Isabelle/HOL proof methods for several decidable logical theories used in C program verification by relying on the existing capabilities of well-known SMT solvers, such as Z3 and proof reconstruction capabilities of the Isabelle/HOL proof assistant.

Taming the Merge Operator

Abstract Calculi with disjoint intersection types support a symmetric merge operator with subtyping. The merge operator generalizes record concatenation to any type, enabling expressive forms of object composition, and simple solutions to hard modularity problems. Unfortunately, recent calculi with disjoint intersection types and the merge operator lack a (direct) operational semantics with expected properties such as determinism and subject reduction, and only account for terminating programs. This paper proposes a type-directed operational semantics (TDOS) for calculi with intersection types and a merge operator. We study two variants of calculi in the literature. The first calculus, called λ i , is a variant of a calculus presented by Oliveira et al. (2016) and closely related to another calculus by Dunfield (2014). Although Dunfield proposes a direct small-step semantics for her calculus, her semantics lacks both determinism and subject reduction. Using our TDOS, we obtain a direct semantics for λ i that has both properties. The second calculus, called λ i + , employs the well-known subtyping relation of Barendregt, Coppo and Dezani-Ciancaglini (BCD). Therefore, λ i + extends the more basic subtyping relation of λ i , and also adds support for record types and nested composition (which enables recursive composition of merged components). To fully obtain determinism, both λ i and λ i + employ a disjointness restriction proposed in the original λ i calculus. As an added benefit the TDOS approach deals with recursion in a straightforward way, unlike previous calculi with disjoint intersection types where recursion is problematic. We relate the static and dynamic semantics of λ i to the original version of the calculus and the calculus by Dunfield. Furthermore, for λ i + , we show a novel formulation of BCD subtyping, which is algorithmic, has a very simple proof of transitivity and allows for the modular addition of distributivity rules (i.e. without affecting other rules of subtyping). All results have been fully formalized in the Coq theorem prover.

Метафизика бытия информации

In article the metaphysics of being of information is considered and her cat­egorical status. The concept of information plays an especially important role in cognitive disciplines – neurology, cognitive psychology, sociology and arti­ficial intelligence theories altogether forming the scientific basis of new epi­stemology. Information is understood as the objective reality perceived by the subject by means of touch bodies which it fixes and comprehends by means of various semantic pro-positions, logical-mathematical operations and calculations, using it in various communicative practices for achievement of the purposes. On the basis of philosophical traditions of interpretation of cat­egory of life and various interpretations of this abstract concept of modern nat­ural sciences the new understanding of category of life as a basic metaphysical concept of science is offered. The philosophical bases of the theory of creative participation of the person in events of the Universe the famous American physicist-theorist J.A. Wheeler who put forward the thesis “all from Bit” (It from Bit), the information paradigm of the universe developed by the prom­inent modern philosopher L. Floridi. It is demonstrated that the origination and evolution of all objects takes place due to the existence of specific information programs that express the fundamental creativity of the nature. The statement that the category of life in modern interpretation both in natural-science, and in sociocultural aspects expresses life of information, or the information life presented in unity of three spheres of reality – matter, lives and consciousness (reason) is proved.

Unformalized tasks and methodology of their solution

The article deals with the methodology of solving non-formalized problems. The first methodology represents the traditional approach to the description of the problem domain model (MPO) and it is characterized by a significant operational semantics. The second description methodology represents a new direction in computer science − artificial intelligence. Any problem for which the solution algorithm is unknown, a priori refers to artificial intelligence. An algorithm is understood as the entire sequence of specified actions that are well defined and can be performed on a computer. The knowledge model is a means of describing the logic and data of the problem being solved. Since the knowledge about the subject area may be inaccurate, incomplete, or unclear, and the subject areas are different, the logic used in the description may also be different. The problem to be solved is presented in the form of rules (statements) and a request, the validity of which should be established or refuted. The solution of the problem is reduced to finding out the logical sequence (derivability) of the target formula from a given set of rules. The most popular knowledge models for creating ES are production models. The frame model, or the model of knowledge representation, based on the frame theory, is a psychological model of human memory and consciousness systematized in the form of a single theory The semantic network model is a knowledge representation model based on the semantic network method. The described models are only a small part of the applied methods for solving unformalized problems.

Adapting TDL to Provide Testing Support for Executable DSLs.

Testing is one of the most prevalent and successful verification and validation (V&V) techniques used in the field of software engineering. While a large number of testing frameworks exist for general-purpose programming languages, providing testing facilities for any given executable Domain Specific Language (xDSL) remains a costly and challenging task. In this context, a standard such as the Test Description Language (TDL) appears as a suitable foundation for the definition of a generic testing approach for xDSLs. Unfortunately, TDL does not provide the domain-specific concepts required to write test cases for a given xDSL and does not include any model execution facilities. Our contribution addresses these limitations and thereby provides a fully generic testing approach for xDSLs based on TDL. Required TDL domain-specific concepts are automatically inferred from the xDSL definition through a model transformation into TDL. Model execution facilities are provided through the definition of a refined operational semantics for TDL. The application of our approach on 5 different xDSLs shows its generality and that it can successfully be used for testing executable models.

A logic of defeasible argumentation: Constructing arguments in justification logic

In the 1980s, Pollock’s work on default reasons started the quest in the AI community for a formal system of defeasible argumentation. The main goal of this paper is to provide a logic of structured defeasible arguments using the language of justification logic. In this logic, we introduce defeasible justification assertions of the type t : F that read as “t is a defeasible reason that justifies F”. Such formulas are then interpreted as arguments and their acceptance semantics is given in analogy to Dung’s abstract argumentation framework semantics. We show that a large subclass of Dung’s frameworks that we call “warranted” frameworks is a special case of our logic in the sense that (1) Dung’s frameworks can be obtained from justification logic-based theories by focusing on a single aspect of attacks among justification logic arguments and (2) Dung’s warranted frameworks always have multiple justification logic instantiations called “realizations”. We first define a new justification logic that relies on operational semantics for default logic. One of the key features that is absent in standard justification logics is the possibility to weigh different epistemic reasons or pieces of evidence that might conflict with one another. To amend this, we develop a semantics for “defeaters”: conflicting reasons forming a basis to doubt the original conclusion or to believe an opposite statement. This enables us to formalize non-monotonic justifications that prompt extension revision already for normal default theories. Then we present our logic as a system for abstract argumentation with structured arguments. The format of conflicting reasons overlaps with the idea of attacks between arguments to the extent that it is possible to define all the standard notions of argumentation framework extensions. Using the definitions of extensions, we establish formal correspondence between Dung’s original argumentation semantics and our operational semantics for default theories. One of the results shows that the notorious attack cycles from abstract argumentation cannot always be realized as justification logic default theories.

A Comparative Study of Formal Approaches for Web Service Oriented Architecture

The security in web service oriented architecture (WSOA) development has become a critical need and goal. WSOA as service-oriented architecture (SOA) designs the software as services and uses the services as platforms. Web services orchestration describes how web services can interact with each other from an operational perspective. Many languages allow expression of executable processes to implementing web services orchestration. These languages are used to describe how the interactions between multiple services are coordinated to achieve a goal. However, the operational semantics of each of the structures of these languages is not formally defined and they have limitations regarding the reasoning and the verification of the web services compositions. Several studies and approaches have been proposed in this context, are devoted to the formalization of web services orchestrations and allow some verification of their behavior; these approaches are partial solutions to the problem of development of the safe composition. We explore the advantages and limitations of more than fourteen approaches and research work. We propose a model for comparison between works, studies, and approaches in this field. The proposed model adopts the concepts of the formalization and the automation of development processes.

Dischargeable Obligations in the 𝒮CIFF Framework

Abductive Logic Programming (ALP) has been proven very effective for formalizing societies of agents, commitments and norms, in particular by mapping the most common deontic operators (obligation, prohibition, permission) to abductive expectations. In our previous works, we have shown that ALP is a suitable framework for representing norms. Normative reasoning and query answering were accommodated by the same abductive proof procedure, named 𝒮CIFF. In this work, we introduce a defeasible flavour in this framework, in order to possibly discharge obligations in some scenarios. Abductive expectations can also be qualified as dischargeable, in the new, extended syntax. Both declarative and operational semantics are improved accordingly, and proof of soundness is given under syntax allowedness conditions Moreover, the dischargement itself might be proved invalid, or incoherent with the rules, due to new knowledge provided later on. In such a case, a discharged expectation might be reinstated and hold again after some evidence is given. We extend the notion of dischargement to take into consideration also the reinstatement of expectations. The expressiveness and power of the extended framework, named 𝒮CIFF𝒟, is shown by modeling and reasoning upon a fragment of the Japanese Civil Code. In particular, we consider a case study concerning manifestations of intention and their rescission (Section II of the Japanese Civil Code).

A Formal, Resource Consumption-Preserving Translation from Actors with Cooperative Scheduling to Haskell*

We present a formal translation of a resource-aware extension of the Abstract Behavioral Specification (ABS) language to the functional language Haskell. ABS is an actor-based language tailored to the modeling of distributed systems. It combines asynchronous method calls with a suspend and resume mode of execution of the method invocations. To cater for the resulting cooperative scheduling of the method invocations of an actor, the translation exploits for the compilation of ABS methods Haskell functions with continuations. The main result of this article is a correctness proof of the translation by means of a simulation relation between a formal semantics of the source language and a high-level operational semantics of the target language, i.e., a subset of Haskell. We further prove that the resource consumption of an ABS program extended with a cost model is preserved over this translation, as we establish an equivalence of the cost of executing the ABS program and its corresponding Haskell-translation. Concretely, the resources consumed by the original ABS program and those consumed by the Haskell program are the same, considering a cost model. Consequently, the resource bounds automatically inferred for ABS programs extended with a cost model, using resource analysis tools, are sound resource bounds also for the translated Haskell programs. Our experimental evaluation confirms the resource preservation over a set of benchmarks featuring different asymptotic costs.

Formalism and semantics of PyCATSHOO: A simulator of distributed stochastic hybrid automata

This article lays the mathematical foundations of PyCATSHOO, a Model-Based Safety Analysis (MBSA) framework relying on distributed stochastic hybrid automata. This tool was initially developed for use cases where continuous evolution of physical variables or component failure rates matter to assess the dependability attributes. The modelling language has been designed in order to provide to the analyst the best expressiveness and ease of use. Nevertheless, although the structure and behaviour of a PyCATSHOO model have been informally described previously, they have never been formally established, which precludes its scientific acceptance and slows down its adoption by new users. To fill this lack, this article introduces formal definitions of the structure of PyCATSHOO models using set theory and of their operational semantics using inference rules (exactly 1 axiom and eight inference rules). These formal definitions are illustrated on a simple case study: the heated room. As a result, our proposing disambiguates the semantics of PyCATSHOO models, provides a formal specification of its input language and the core logic of its simulator engine and paves the way to the integration of model checking techniques in the PyCATSHOO framework.

An Algebraic Graph Transformation Approach for RDF and SPARQL

We consider the recommendations of the World Wide Web Consortium (W3C) about RDF framework and its associated query language SPARQL. We propose a new formal framework based on category theory which provides clear and concise formal definitions of the main basic features of RDF and SPARQL. We define RDF graphs as well as SPARQL basic graph patterns as objects of some nested categories. This allows one to clarify, in particular, the role of blank nodes. Furthermore, we consider basic SPARQL CONSTRUCT and SELECT queries and formalize their operational semantics following a novel algebraic graph transformation approach called POIM.

Europeana, EDM, and the Europeanisation of Cultural Heritage Institutions

Abstract Over the past two decades, the European Commission has mobilised cultural heritage to bolster a European identity. One of the main flagship initiatives promoted to this end has been Europeana, the most extensive digital cultural project financed by the EU. At the core of the project stands europeana.eu, a digital cultural portal aggregating metadata provided by national and local heritage institutions. Central in our analysis is the Europeana Data Model (EDM). Using standardised thesauri and vocabularies, EDM offers the possibility to create a semantic contextualisation for objects, allowing semantic operations on the metadata and their enrichment with Linked Open Data on the web. Due to its overarching nature, EDM cannot deliver the granularity that cultural heritage institutions need when documenting their resources. Nonetheless, heritage institutions accept to sacrifice accuracy to have their information represented in a Europewide collection. We study how this digital heritage infrastructure was designed to enact a sense of Europeanness amongst national and local institutions. Policy documents, ethnographic research and a systematic survey amongst the European heritage institutions enabled us to trace how a standardised European metadata structure plays a role in governing local and national heritage institutions. The EDM might enable heritage stakeholders to benefit from Europeana’s online exposure while enacting a European mindset. Ultimately, this study of the metadata model enriches the debate on the EU’s cultural heritage politics, which has not fully explored the role of the digital. At the same time, it also taps into debates about infrastructure and digital governmentality.

Semantics of temporal constrained objects

This paper presents the declarative and operational semantics for the paradigm of temporal constrained objects (TCOB). This modeling paradigm is an extension of basic constrained objects where objects specify the structure of a system and constraints specify its behavior. Temporal constrained objects have been shown to provide a clear and high-level declarative specification of the time-dependent behavior of complex dynamic systems. Two key features of this paradigm are series variables and metric temporal operators. The main contribution of this paper lies in showing how we can define the semantics of temporal constrained objects in terms of a new paradigm called temporal constraint logic programs (TCLP), which extend temporal logic programs with constraint-solving. Compared with the several other logical languages incorporating constraints and temporal logic, the TCLP paradigm offers a clear and direct way of translating temporal constrained object programs using three simple temporal predicates: first p, next p, and prev p. The key approach is to map each class in a TCOB program to a predicate in the TCLP paradigm. Thus, the semantics of recursively defined classes is expressed in terms of the semantics of recursively defined predicates, a well-understood topic. Given the close connections between TCLP and CLP, we take advantage of the semantics of CLP for providing the declarative and operational semantics of TCLP and thereby also of temporal constrained objects.

Dynamics of reputation in mobile agents systems and weighted timed automata

The reputation of a process is based on its past and present behaviour; it evolves in time depending on several factors including the actions performed, the reputation of its interacting processes and locations where the process resides. We design a calculus of mobile agents in distributed systems able to handle the dynamics of reputation which changes over time depending on specified factors. The main idea is to provide a formal understanding of how reputation is formed from complex interactions in agent systems based on timed migration and communication, and how we can verify automatically the properties involving reputation. After presenting the operational semantics of our calculus and some results, the mobile agents described easily in this calculus are translated into networks of weighted timed automata having a bisimilar behaviour. Based on this translation, we use an existing software platform to analyze reputation-based properties of mobile agents in distributed systems.

Knowing when to ask: sound scheduling of name resolution in type checkers derived from declarative specifications

There is a large gap between the specification of type systems and the implementation of their type checkers, which impedes reasoning about the soundness of the type checker with respect to the specification. A vision to close this gap is to automatically obtain type checkers from declarative programming language specifications. This moves the burden of proving correctness from a case-by-case basis for concrete languages to a single correctness proof for the specification language. This vision is obstructed by an aspect common to all programming languages: name resolution. Naming and scoping are pervasive and complex aspects of the static semantics of programming languages. Implementations of type checkers for languages with name binding features such as modules, imports, classes, and inheritance interleave collection of binding information (i.e., declarations, scoping structure, and imports) and querying that information. This requires scheduling those two aspects in such a way that query answers are stable—i.e., they are computed only after all relevant binding structure has been collected. Type checkers for concrete languages accomplish stability using language-specific knowledge about the type system. In this paper we give a language-independent characterization of necessary and sufficient conditions to guarantee stability of name and type queries during type checking in terms of critical edges in an incomplete scope graph . We use critical edges to give a formal small-step operational semantics to a declarative specification language for type systems, that achieves soundness by delaying queries that may depend on missing information. This yields type checkers for the specified languages that are sound by construction—i.e., they schedule queries so that the answers are stable, and only accept programs that are name- and type-correct according to the declarative language specification. We implement this approach, and evaluate it against specifications of a small module and record language, as well as subsets of Java and Scala.

Provably correct implementation of the AbC calculus

Building open, distributed systems while guaranteeing a specific behaviour is difficult because of the dynamicity of the operating environments and the complexity of the interactions of their components. The AbC calculus provides a novel communication mechanism to select interacting partners based on their runtime capabilities, making it naturally to model complex interactions and adaptive behaviour in such systems. The formal account of this calculus has enabled constructing formally verifiable models and proving their properties. In this paper, we i) propose an implementation of AbC using the Erlang language ii) formalize the operational semantics of our implementation; iii) propose a set of rules that given an AbC specification, automatically generate Erlang executable code; and iv) prove that the proposed translation is correct by establishing a simulation relation between source and target specifications. This enables us to guarantee that any property proved for a given AbC specification is preserved by the corresponding implementation.

Abstracting Strings for Model Checking of C Programs

Data type abstraction plays a crucial role in software verification. In this paper, we introduce a domain for abstracting strings in the C programming language, where strings are managed as null-terminated arrays of characters. The new domain M-String is parametrized on an index (bound) domain and a character domain. By means of these different constituent domains, M-Strings captures shape information on the array structure as well as value information on the characters occurring in the string. By tuning these two parameters, M-String can be easily tailored for specific verification tasks, balancing precision against complexity. The concrete and the abstract semantics of basic operations on strings are carefully formalized, and soundness proofs are fully detailed. Moreover, for a selection of functions contained in the standard C library, we provide the semantics for character access and update, enabling an automatic lifting of arbitrary string-manipulating code into our new domain. An implementation of abstract operations is provided within a tool that automatically lifts existing programs into the M-String domain along with an explicit-state model checker. The accuracy of the proposed domain is experimentally evaluated on real-case test programs, showing that M-String can efficiently detect real-world bugs as well as to prove that program does not contain them after they are fixed.

Time-bounded termination analysis for probabilistic programs with delays

This paper investigates the model of probabilistic program with delays (PPD) that consists of a few program blocks. Performing each block has an additional time-consumption—waiting to be executed—besides the running time. We interpret the operational semantics of PPD by Markov automata with a cost structure on transitions. Our goal is to measure those individual execution paths of a PPD that terminates within a given time bound, and to compute the minimum termination probability, i.e. the termination probability under a demonic scheduler that resolves the nondeterminism inherited from probabilistic programs. When running time plus waiting time is bounded, the demonic scheduler can be determined by comparison between a class of well-formed real numbers. The method is extended to parametric PPDs. When only the running time is bounded, the demonic scheduler can be determined by real root isolation over a class of well-formed real functions under Schanuel's conjecture. Finally we give the complexity upper bounds of the proposed methods.

Pragmatic reuse for DSML development

By bridging the semantic gap, domain-specific language (DSLs) serve an important role in the conquest to allow domain experts to model their systems themselves. In this publication we present a case study of the development of the Continuous REactive SysTems language (CREST), a DSL for hybrid systems modeling. The language focuses on the representation of continuous resource flows such as water, electricity, light or heat. Our methodology follows a very pragmatic approach, combining the syntactic and semantic principles of well-known modeling means such as hybrid automata, data-flow languages and architecture description languages into a coherent language. The borrowed aspects have been carefully combined and formalised in a well-defined operational semantics. The DSL provides two concrete syntaxes: CREST diagrams, a graphical language that is easily understandable and serves as a model basis, and crestdsl, an internal DSL implementation that supports rapid prototyping—both are geared towards usability and clarity. We present the DSL’s semantics, which thoroughly connect the various language concerns into an executable formalism that enables sound simulation and formal verification in crestdsl, and discuss the lessons learned throughout the project.

Intuitionistic fixed point logic

We study the system IFP of intuitionistic fixed point logic, an extension of intuitionistic first-order logic by strictly positive inductive and coinductive definitions. We define a realizability interpretation of IFP and use it to extract computational content from proofs about abstract structures specified by arbitrary classically true disjunction free formulas. The interpretation is shown to be sound with respect to a domain-theoretic denotational semantics and a corresponding lazy operational semantics of a functional language for extracted programs. We also show how extracted programs can be translated into Haskell. As an application we extract a program converting the signed digit representation of real numbers to infinite Gray code from a proof of inclusion of the corresponding coinductive predicates.