Abstract: In this article, we examine an argument-based semantics called semi-stable semantics Semi-stable semantics is quite close to traditional stable semantics in the sense that every stable extension is also a semi-stable extension One of the advantages of semi-stable semantics is that for finite argumentation frameworks there always exists at least one semi-stable extension Furthermore, if there also exists at least one stable extension, then the semi-stable extensions coincide with the stable extensions Semi-stable semantics can be seen as a general approach that can be applied to abstract argumentation, as well as to fields like default logic and answer set programming, yielding an interpretation with properties very similar to those of paraconsistent logic, including the properties of crash resistance and backward compatibility

Abstract: Approximation Fixpoint Theory was developed as a fixpoint theory of lattice operators that provides a uniform formalization of four main semantics of three major nonmonotonic reasoning formalisms. This paper clarifies how this fixpoint theory can define the stable and well-founded semantics of logic programs. It investigates the notion of strong equivalence underlying this semantics. It also shows the remarkable power of this theory for defining natural and elegant versions of these semantics for extensions of logic and answer set programs. In particular, we here consider extensions with general rule bodies, general interpretations (also non-Herbrand interpretations) and aggregates. We also investigate the relationship with the equilibrium semantics of nested answer set programs, on the formal and the informal level.

Abstract: This paper presents a nine-rule language-independent proof system that takes an operational semantics as axioms and derives program reachability properties, including ones corresponding to Hoare triples. This eliminates the need for language-specific Hoare-style proof rules to verify programs, and, implicitly, the tedious step of proving such proof rules sound for each language separately. The key proof rule is Circularity, which is coinductive in nature and allows for reasoning about constructs with repetitive behaviors (e.g., loops). The generic proof system is shown sound and has been implemented in the MatchC verifier.

Abstract: We show that there is no finitely axiomatizable class of algebras that would serve as an analogue to Kozen’s class of Kleene algebras if we include the residuals of composition in the similarity type of relation algebras.

Abstract: Separation Logic has witnessed tremendous success in recent years in reasoning about programs that deal with heap storage. Its success owes to the fundamental principle that one should keep separate areas of the heap storage separate in program reasoning. However, the way Separation Logic deals with program variables continues to be based on traditional Hoare Logic without taking any benefit of the separation principle. This has led to unwieldy proof rules suffering from lack of clarity as well as questions surrounding their soundness. In this paper, we extend the separation idea to the treatment of variables in Separation Logic, especially Concurrent Separation Logic, using the system of Syntactic Control of Interference proposed by Reynolds in 1978. We extend the original system with permission algebras, making it more powerful and able to deal with the issues of concurrent programs. The result is a streamined presentation of Concurrent Separation Logic, whose rules are memorable and soundness obvious. We also include a discussion of how the new rules impact the semantics and devise static analysis techniques to infer the required permissions automatically.

Abstract: This paper revisits the idea of slicing programs based on their axiomatic semantics, rather than using criteria based on control/data dependencies. We show how the forward propagation of preconditions and the backward propagation of postconditions can be combined in a new slicing algorithm that is more precise than the existing specification-based algorithms. The algorithm is based on (a) a precise test for removable statements, and (b) the construction of a slice graph, a program control flow graph extended with semantic labels and additional edges that “short-circuit” removable commands. It improves on previous approaches in two aspects: it does not fail to identify removable commands; and it produces the smallest possible slice that can be obtained (in a sense that will be made precise). Iteration is handled through the use of loop invariants and variants to ensure termination. The paper also discusses in detail applications of these forms of slicing, including the elimination of (conditionally) unreachable and dead code, and compares them to other related notions.

Abstract: Runtime verification of temporal logic properties requires a definition of the truth value of these properties on the finite paths that are observed at runtime. However, while the semantics of temporal logic on infinite paths has been precisely defined, there is not yet an agreement on the definition of the semantics on finite paths. Recently, it has been observed that the accuracy of runtime verification can be improved by a 4-valued semantics of temporal logic on finite paths. However, as we argue in this paper, even a 4-valued semantics is not sufficient to achieve a semantics on finite paths that converges to the semantics on infinite paths. To overcome this deficiency, we consider in this paper Manna and Pnueli's temporal logic hierarchy consisting of safety, liveness (guarantee), co-Buchi (persistence), and Buchi (recurrence) properties. We propose the use of specialized semantics for each of these subclasses to improve the accuracy of runtime verification. In particular, we prove that our new semantics converges to the infinite path semantics which is an important property that has not been achieved by previous approaches.

Abstract: Results of Schlipf (J Comput Syst Sci 51:64---86, 1995) and Fitting (Theor Comput Sci 278:25---51, 2001) show that the well-founded semantics of a finite predicate logic program can be quite complex. In this paper, we show that there is a close connection between the construction of the perfect kernel of a $\Pi^0_1$ class via the iteration of the Cantor---Bendixson derivative through the ordinals and the construction of the well-founded semantics for finite predicate logic programs via Van Gelder's alternating fixpoint construction. This connection allows us to transfer known complexity results for the perfect kernel of $\Pi^0_1$ classes to give new complexity results for various questions about the well-founded semantics ${\mathit{wfs}}(P)$ of a finite predicate logic program P.

Abstract: In this work, we present a framework based on the notion of dependencies. We use this framework to define semantics for inconsistent belief bases in a modular way to define general tools for handling inconsistency. We consider belief bases represented by non-monotonic formalisms, and in particular use extended logic programs and belief bases represented by sequences of these. We show the presented frameworks appliance with the answer set semantics for consistent belief bases. Moreover, we define various instantiations of the framework and show relations to other approaches. We present ways to improve the resulting semantics by means of changes to modules of the framework that lead to the definition of improved approaches to conflict handling in logic programming-based knowledge bases.

Abstract: Logic programs with abstract constraint atoms proposed by Marek and Truszczynski are very general logic programs. They are general enough to capture aggregate logic programs as well as recently proposed description logic programs. In this paper, we propose a well-founded semantics for basic logic programs with arbitrary abstract constraint atoms, which are sets of rules whose heads have exactly one atom. We show that similar to the well-founded semantics of normal logic programs, it has many desirable properties such as that it can be computed in polynomial time, and is always correct with respect to the answer set semantics. This paves the way for using our well-founded semantics to simplify these logic programs. We also show how our semantics can be applied to aggregate logic programs and description logic programs, and compare it to the well-founded semantics already proposed for these logic programs.

Abstract: The FLP semantics presented by (Faber, Leone, and Pfeifer 2004) has been widely used to define answer sets, called FLP answer sets, for different types of logic programs such as logic programs with aggregates, description logic programs (dl-programs), Hex programs, and logic programs with first-order formulas (general logic programs). However, it was recently observed that the FLP semantics may produce unintuitive answer sets with circular justifications caused by self-supporting loops. In this paper, we address the circular justification problem for general logic programs by enhancing the FLP semantics with a level mapping formalism. In particular, we extend the Gelfond-Lifschitz three step definition of the standard answer set semantics from normal logic programs to general logic programs and define for general logic programs the first FLP semantics that is free of circular justifications.We call this FLP semantics the well-justified FLP semantics. This method naturally extends to general logic programs with additional constraints like aggregates, thus providing a unifying framework for defining the well-justified FLP semantics for various types of logic programs. When this method is applied to normal logic programs with aggregates, the well-justified FLP semantics agrees with the conditional satisfaction based semantics defined by (Son, Pontelli, and Tu 2007); and when applied to dl-programs, the semantics agrees with the strongly well-supported semantics defined by (Shen 2011).

Abstract: Many semantic theories implicitly attribute a foundational status to set theory, and set-theoretic characterisations of possible worlds in particular. The goal of a semantic theory is then to find a translation of the phenomena of interest into a settheoretic model. This can be contrasted with an axiomatic approach in which we can formulate “new” primitives and ontological categories, and devise logical rules and axioms that capture the appropriate inferential behaviour. This alternative approach might be criticised as being mere “descriptivism”, lacking predictive or explanatory power. Here we will seek to defend the axiomatic approach. Any formal account must assume some intended interpretation, but there is a sense in which such theories can provide a more honest characterisation. In contrast, the set-theoretic approach tends to conflate distinct ontological notions. Mapping a pattern of semantic behaviour into some pre-existing set-theoretic behaviour may lead to certain aspects of meaning being overlooked, or ignored.

Abstract: Matching logic has been recently proposed as an alternative program verification approach. Unlike Hoare logic, where one defines a language-specific proof system that needs to be proved sound for each language separately, matching logic provides a language-independent and sound proof system that directly uses the trusted operational semantics of the language as axioms. Matching logic thus has a clear practical advantage: it eliminates the need for an additional semantics of the same language in order to reason about programs, and implicitly eliminates the need for tedious soundness proofs. What is not clear, however, is whether matching logic is as powerful as Hoare logic. This paper introduces a technique to mechanically translate Hoare logic proof derivations into equivalent matching logic proof derivations. The presented technique has two consequences: first, it suggests that matching logic has no theoretical limitation over Hoare logic; and second, it provides a new approach to prove Hoare logics sound.

Abstract: Ontologies are one of the most important layers on semantic web. Inconsistencies observed on cascading changes of thousands of nodes may arise simply because of a small operation on an ontology component. We proposed in this paper an approach that consists in ontology restructuring according to a lexical model that makes possible to model change operations as transformer state based on Hoare's axiomatic semantic. It thus helps proving their satisfiability and the way they change the ontology state through its components.

Abstract: Logic programs with aggregates and description logic programs (dl-programs) are two recent extensions to logic programming. In this paper, we study the relationships between these two classes of logic programs, under the well-founded semantics. The main result is that, under a satisfaction-preserving mapping from dl-atoms to aggregates, the well-founded semantics of dl-programs by Eiter et al., coincides with the well-founded semantics of aggregate programs, defined by Pelov et al. as the least fixpoint of a 3-valued immediate consequence operator under the ultimate approximating aggregate. This result enables an alternative definition of the same well-founded semantics for aggregate programs, in terms of the first principle of unfounded sets. Furthermore, the result can be applied, in a uniform manner, to define the well-founded semantics for dl-programs with aggregates, which agrees with the existing semantics when either dl-atoms or aggregates are absent.

Abstract: Two lines of developing the C program verification project at the A.P. Ershov Institute of Informatic Systems are presented. Firstly, the axiomatic semantics of the C-kernel language was extended by the semantic labelling. The labels introduced in the Hoare calculus correspond to various concepts inherent in verification conditions (VC). These labels can be extracted from terms and rendered into explanations written in the natural language. User friendly explanations can play a crucial role in VC understanding and error localization. Secondly, a subset of the C standard library was specified. The specifications written in ACSL correspond to the C-light memory model. Examples illustrating the use of the proposed techniques are presented.

Abstract: In this paper we present an approach based on software components for developing distributed applications, we use mobile agents as connectors between components to support the execution of the composition (assembly). We use also mobile agents to verify the validity of compositions to achieve the functionality provided by the application. We treat the validity of the components composition in a functional point of view and a structural point of view, in the first one we propose a fuzzy axiomatic semantics of a concurrent programming language to measure to what degree the behavior resulting from the expected composition will satisfy the expected functionality from the application. In the second point we treat a structural point of view related to the dynamics of the network environment, in this point we use mobile agents to ensure structural validity criteria.

Abstract: We propose a novel semantics for semi-negative abductive logic programs (ie where the only negative literals are abducibles) with implicative integrity constraints (ie in the form of implications) This semantics combines answer set programming (with the implicative integrity constraints) and argumentation (for relevant explanations with the logic program, supported by abducibles) We argue that this semantics is better suited than the standard semantics to deal with applications of abductive logic programming and prove some properties of this semantics We motivate our approach in an agent-based access control policy scenario

Abstract: Logic programming under the stable model semantics has been extended to arbitrary formulas. A question of interest is how to characterize the property of well-supportedness, in the sense of Fages, which has been considered a cornerstone in answer set programming. In this paper, we address this issue by considering general logic programs, which consist of disjunctive rules with arbitrary propositional formulas in rule bodies. We define the justified stable semantics for these programs, propose a general notion of well-supportedness, and show the relationships between the two. We address the issue of computational complexity for various classes of general programs. Finally, we show that previously proposed well-supported semantics for aggregate programs and description logic programs are rooted in the justified stable semantics of general programs.

Abstract: In systems verification we are often concerned with multiple, inter-dependent properties that a program must satisfy. To prove that a program satisfies a given property, the correctness of intermediate states of the program must be characterized. However, this intermediate reasoning is not always phrased such that it can be easily re-used in the proofs of subsequent properties. We introduce a function annotation logic that extends Hoare logic in two important ways: (1) when proving that a function satisfies a Hoare triple, intermediate reasoning is automatically stored as function annotations, and (2) these function annotations can be exploited in future Hoare logic proofs. This reduces duplication of reasoning between the proofs of different properties, whilst serving as a drop-in replacement for traditional Hoare logic to avoid the costly process of proof refactoring. We explain how this was implemented in Isabelle/HOL and applied to an experimental branch of the seL4 microkernel to significantly reduce the size and complexity of existing proofs.

Abstract: The paper presents a simple and concise proof of correctness of the magic transformation. We believe that it may provide a useful example of formal reasoning about logic programs. The correctness property concerns the declarative semantics. The proof, however, refers to the operational semantics (LD-resolution) of the source programs. Its conciseness is due to applying a suitable proof method.

Abstract: The correctness of logic programs which are constructed by a schema-based method is presented in this paper. This schema-based method constructs typed, moded logic programs by stepwise top-down design using five program schemata, data types and modes. Correctness proofs in this approach are guided by the constructed logic programs. A proof scheme is proposed for each program schema. It is claimed that the structure of a logic program constructed by this schema-based method is reflected in the structure of its correctness proof. The proof schemes which correspond to design schemata are followed in the correctness proofs of logic programs.

Abstract: In this paper, a new kind of annotations called attribute annotations and the methodology for their application in deductive program verification are proposed. A collection of annotating attributes for the C-kernel subset of the C language is described, and, on their basis, two versions of axiomatic semantics of C-kernel—forward semantics and mixed forward semantics—are presented.

Abstract: In this paper, we present a general schema for de ning new update semantics. This schema takes as input any basic logic programming semantics, such as the stable semantics, the p-stable semantics or the MMr semantics, and gives as output a new update semantics. The schema proposed is based on a concept called minimal generalized S models, where S is any of the logic programming semantics. Each update semantics is associated to an update operator. We also present some properties of these update operators.

Abstract: In this paper we present an approach to formalizing the general rules of the Hoare logic that is based on formulas of the first-order predicate logic defined over the abstract state space of a virtual machine, i.e. so-called S-formulas. The general rules of Hoare logic, such as the rules of consequence, conjunction, disjunction and negation can be derived using axioms and theorems of first-order predicate logic. Every proof is based on deriving the validity of some S-formula, so the procedure may be automated using automatic theorem provers, such as Coq.