Expressing and Verifying Business Contracts with Abductive

One major problem in the process of knowledge assimilation is how to deal with inconsistency of new knowledge and the existing knowledge base. In this paper we present a formal, provably correct and yet computational methodology for assimilation of new knowledge into knowledge bases about actions and changes based on the slogan: what is believed is what is explained. Technically, we employ Gelfond and Lifschitz' action description language A to describe domains of actions. The knowledge bases on domains of actions are defined and obtained by a new translation from domain descriptions in A into abductive normal logic programs, where a time dimension is incorporated. The knowledge bases are shown to be both sound and complete with respect to their domain descriptions. In particular, we propose a possible causes approach (PCA) to knowledge assimilation about evolving domains of actions, in contrast to Ginsberg's possible worlds approach (PWA) and Winslett's possible models approach (PMA). A possible cause of new knowledge consists of abduced occurrences of actions and value propositions about the initial state of the domain of actions, that would allow to derive the new knowledge. We show how to compute possible causes with abductive logic programming, and present some techniques to improve search efficiency. We use examples to compare our possible causes approach with syntax-based approaches, such as Ginsberg's possible worlds approach, and semantics-based approaches, such as Winslett's possible models approach, to belief revision/update.

The task of inverting logical entailment is of central importance to the disciplines of Abductive and Inductive Logic Programming (ALP & ILP). Bottom Generalisation (BG) is a widely applied approach for Inverse Entailment (IE), but is limited to deriving single clauses from a hypothesis space restricted by Plotkin’s notion of C-derivation. Moreover, known practical applications of BG are confined to Horn clause logic. Recently, a hybrid ALP-ILP proof procedure, called HAIL, was shown to generalise existing BG techniques by deriving multiple clauses in response to a single example, and constructing hypotheses outside the semantics of BG. The HAIL proof procedure is based on a new semantics, called Kernel Set Subsumption (KSS), which was shown to be a sound generalisation of BG. But so far KSS is defined only for Horn clauses. This paper extends the semantics of KSS from Horn clause logic to general clausal logic, where it is shown to remain a sound extension of BG. A generalisation of the C-derivation, called a K*-derivation, is introduced and shown to provide a sound and complete characterisation of KSS. Finally, the K*-derivation is used to provide a systematic comparison of existing proof procedures based on IE.

Abduction is a form of inference that supports hypothetical reasoning and has been applied to a number of domains, such as diagnosis, planning, protocol verification. Abductive Logic Programming (ALP) is the integration of abduction in logic programming. Usually, the operational semantics of an ALP language is defined as a proof procedure. The first implementations of ALP proof-procedures were based on the meta-interpretation technique, which is flexible but limits the use of the built-in predicates of logic programming systems. Another, more recent, approach exploits theoretical results on the similarity between abducibles and constraints. With this approach, which bears the advantage of an easy integration with built-in predicates and constraints, Constraint Handling Rules has been the language of choice for the implementation of abductive proof procedures. The first CHR-based implementation mapped integrity constraints directly to CHR rules, which is an efficient solution, but prevents defined predicates from being in the body of integrity constraints and does not allow a sound treatment of negation by default. In this paper, we describe the CHR-based implementation of the SCIFF abductive proof-procedure, which follows a different approach. The SCIFF implementation maps integrity constraints to CHR constraints, and the transitions of the proof-procedure to CHR rules, making it possible to treat default negation, while retaining the other advantages of CHR-based implementations of ALP proof-procedures.

Three-valued completion for abductive logic programs

<span lang="EN-US">Network Function Virtualization (NFV) architectures are emerging to increase networks flexibility. However, this renewed scenario poses new challenges, because virtualized networks, need to be carefully verified before being actually deployed in production environments in order to preserve network coherency (e.g., absence of forwarding loops, preservation of security on network traffic, etc.). Nowadays, model checking tools, SAT solvers, and Theorem Provers are available for formal verification of such properties in virtualized networks. Unfortunately, most of those verification tools accept input descriptions written in specification languages that are difficult to use for people not experienced in formal methods. Also, in order to enable the use of formal verification tools in real scenarios, vendors of Virtual Network Functions (VNFs) should provide abstract mathematical models of their functions, coded in the specific input languages of the verification tools. This process is error-prone, time-consuming, and often outside the VNF developers’ expertise. This paper presents a framework that we designed for automatically extracting verification models starting from a Java-based representation of a given VNF. It comprises a Java library of classes to define VNFs in a more developer-friendly way, and a tool to translate VNF definitions into formal verification models of different verification tools.</span>

Network Function Virtualization (NFV) architectures are emerging to increase networks flexibility. However, this renewed scenario poses new challenges, because virtualized networks, need to be carefully verified before being actually deployed in production environments in order to preserve network coherency (e.g., absence of forwarding loops, preservation of security on network traffic, etc.). Nowadays, model checking tools, SAT solvers, and Theorem Provers are available for formal verification of such properties in virtualized networks. Unfortunately, most of those verification tools accept input descriptions written in specification languages that are difficult to use for people not experienced in formal methods. Also, in order to enable the use of formal verification tools in real scenarios, vendors of Virtual Network Functions (VNFs) should provide abstract mathematical models of their functions, coded in the specific input languages of the verification tools. This process is error-prone, time-consuming, and often outside the VNF developers' expertise. This paper presents a framework that we designed for automatically extracting verification models starting from a Java based representation of a given VNF. It comprises a Java library of classes to define VNFs in a more developer-friendly way, and a tool to translate VNF definitions into formal verification models of different verification tools.

The Erlang Verification Tool is an interactive theorem prover tailored to verify properties of distributed systems implemented in Erlang. It is being developed by the Swedish Institute of Computer Science in collaboration with Ericsson.In this paper we present an extension of this tool which allows to reason about the Erlang code on an architectural level. We present a verification methodfor client-server systems designed using the generic server implementation of the Open Telecom Platform. For this purpose, we specify a set of transition rules which characterize the abstract behaviour of the generic server functions. By this means we can reason in a partitioned w ay about any client-server application without having to consider the concrete implementation details of the generic part, which simplifies proofs dramatically.The generic server architecture is just an example, and the technique extends to many other generic components. Moreover, the idea of considering standard components to reason on the architectural level of a concrete implementation can also be explored when using other verifications tools for Erlang or in the context of another language.KeywordsServer ProcessOperational SemanticTransition RuleLogical FormulaProof RuleThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Large Language Models (LLMs) are increasingly used in industrial monitoring and decision support, yet they remain prone to process-control hallucinations—diagnoses and explanations that sound plausible but conflict with physical constraints, sensor data, or plant dynamics. This paper investigates hallucination as a failure of abductive reasoning, where missing premises, weak mechanistic support, or counter-evidence lead an LLM to propose incorrect causal narratives for faults such as pump restriction, valve stiction, fouling, or reactor runaway. We develop a neuro-symbolic framework in which Abductive Logic Programming (ALP) evaluates the coherence of model-generated explanations, counter-abduction generates rival hypotheses that test whether the explanation can be defeated, and Discourse-weighted ALP (D-ALP) incorporates nucleus–satellite structure from operator notes and alarm logs to weight competing explanations. Using our 500-scenario Process-Control Hallucination Dataset, we assess LLM reasoning across mechanistic, evidential, and contrastive dimensions. Results show that abductive and counter-abductive operators substantially reduce explanation-level hallucinations and improve alignment with physical process behavior, particularly in “easy-but-wrong’’ cases where a superficially attractive explanation contradicts historian trends or counter-evidence. These findings demonstrate that abductive reasoning provides a practical and verifiable foundation for improving LLM reliability in safety-critical process-control environments.

The logic program formalism is commonly viewed as a modal or default logic. In this paper, we propose an alternative interpretation of the formalism as a terminological logic. A terminological logic is designed to represent two different forms of knowledge. A TBox represents definitions for a set of concepts. An ABox represents the assertional knowledge of the expert. In our interpretation, a logic program is a TBox providing definitions for all predicates; this interpretation is present already in Clark's completion semantics. We extend the logic program formalism such that some predicates can be left undefined and use classical logic as the language for the ABox. The resulting logic can be seen as an alternative interpretation of abductive logic program formalism. We study the expressivity of the formalism for representing uncertainty by proposing solutions for problems in temporal reasoning, with null values and open domain knowledge.

We define abstract proof procedures for performing credulous and sceptical non-monotonic reasoning, with respect to the argumentation-theoretic formulation of non-monotonic reasoning proposed in [1]. Appropriate instances of the proposed proof procedures provide concrete proof procedures for concrete formalisms for non-monotonic reasoning, for example logic programming with negation as failure and default logic.We propose (credulous and sceptical) proof procedures under different argumentation-theoretic semantics, namely the conventional stable model semantics and the more liberal partial stable model or preferred extension semantics. We study the relationships between proof procedures for different semantics, and argue that, in many meaningful cases, the (simpler) proof procedures for reasoning under the preferred extension semantics can be used as sound and complete procedures for reasoning under the stable model semantics. In many meaningful cases still, proof procedures for credulous reasoning under the preferred extension semantics can be used as (much simpler) sound and complete procedures for sceptical reasoning under the preferred extension semantics. We compare the proposed proof procedures with existing proof procedures in the literature.

Specifications and prototyping are valuable means to help software engineers when developing complicated systems. In this paper, we propose a method for specifying a multi-agent system using coloured Petri net (CPN). By representing the coloured Petri net as an abductive logic programming (which is an extension of logic (LP) programming and is purely based on classical logic), a prototype is immediately resulted. Every inference step of the implementation of the prototype can be regarded as a kind of equivalence preserved transformation. We call our framework CPN-LP and use an example on Dutch auction protocol to illustrate its application.

One of the modern paradigms to develop an application is object oriented analysis and design. In this paradigm, there are several objects and each object plays some specific roles in applications. In an application, we must distinguish between procedural semantics and declarative semantics for their implementation in a specific programming language. For the procedural semantics, we can write a set of instructions that must be executed sequentially. The declarative semantics declare a set of facts and rules. They do not specify the sequence of steps for doing the processing. In this paper, we present four taxonomies for the rules in object-oriented paradigm and discuss how the paradigm can be extended to support declarative semantic of applications. Then, the rules in the taxonomies are evaluated in four case studies. After that, an approach is recommended for finding and implementation of declarative semantics, based on some practical experience obtained from the evaluation.

Web Sites Repairing through Abduction

In this paper we show how an object-oriented specification language is useful for the specification of distributed systems. The main constructors in this language are the objects. An object consists of a state, a behaviour and a set of transition rules between states. The specification is composed of three sections: definition of algebraic data types to represent the domain of object attributes, definition of classes that group objects with common features, and definition of relationships among classes. We show two possible styles for defining the behaviour of objects, on one hand we use a transition system (state oriented) and on the other hand we use an algebraic model of processes description (constraint oriented). We illustrate the paper with the specification of the dining philosophers problem, a typical example in distributed programming. >

A myriad of proprietary (i.e., commercial tool specific) verification assertion languages exist today. These languages emerged due to the lack of formal language constructs supporting assertion specification in today’s hardware description languages (HDL). The method described in this paper presents a unique process for unifying (or neutralizing the effects of) the many proprietary languages by using a set of predefined specification modules instantiated as assertions within the designer’s HDL. This methodology creates numerous advantages and precludes the need to introduce new HDL constructs (i.e., extensions to Verilog are not required). It enables the design engineer to “specify once,” then leverage the same HDL assertion specification over multiple verification processes -- such as traditional simulation, semi-formal, and formal verification tools. It also eliminates the need for the design engineer to master tool specific and proprietary language details. Furthermore, this methodology enables evaluating new verification processes and tools (containing their own proprietary languages) seamlessly for the duration of the project, without the need to modify the original HDL text.