arXiv subjects

Martin Strecker

Publications and source records attributed to Martin Strecker.

6 recordsLinked to original sources

arXiv2022

User Guided Abductive Proof Generation for Answer Set Programming Queries (Extended Version)

We present a method for generating possible proofs of a query with respect to a given Answer Set Programming (ASP) rule set using an abductive process where the space of abducibles is automatically constructed just from the input rules alone. Given a (possibly empty) set of user provided facts, our method infers any additional facts that may be needed for the entailment of a query and then outputs these extra facts, without the user needing to explicitly specify the space of all abducibles. We also present a method to generate a set of directed edges corresponding to the justification graph for the query. Furthermore, through different forms of implicit term substitution, our method can take user provided facts into account and suitably modify the abductive solutions. Past work on abduction has been primarily based on goal directed methods. However these methods can result in solvers that are not truly declarative. Much less work has been done on realizing abduction in a bottom up solver like the Clingo ASP solver. We describe novel ASP programs which can be run directly in Clingo to yield the abductive solutions and directed edge sets without needing to modify the underlying solving engine.

cs.AI↗

arXiv2022

Automating Defeasible Reasoning in Law

The paper studies defeasible reasoning in rule-based systems, in particular about legal norms and contracts. We identify rule modifiers that specify how rules interact and how they can be overridden. We then define rule transformations that eliminate these modifiers, leading in the end to a translation of rules to formulas. For reasoning with and about rules, we contrast two approaches, one in a classical logic with SMT solvers as proof engines, one in a non-monotonic logic with Answer Set Programming solvers.

cs.AI↗

arXiv2018

On the Verification of Logically Decorated Graph Transformations

We address the problem of reasoning on graph transformations featuring actions such as \emph{addition} and \emph{deletion} of nodes and edges, node \emph{merging} and \emph{cloning}, node or edge \emph{labelling} and edge \emph{redirection}. First, we introduce the considered graph rewrite systems which are parameterized by a given logic $\mathcal{L}$. Formulas of $\mathcal{L}$ are used to label graph nodes and edges. In a second step, we tackle the problem of formal verification of the considered rewrite systems by using a Hoare-like weakest precondition calculus. It acts on triples of the form $\{\texttt{Pre}\}(\texttt{R},\texttt{strategy}) \{\texttt{Post}\}$ where \texttt{Pre} and \texttt{Post} are conditions specified in the given logic $\mathcal{L}$, \texttt{R} is a graph rewrite system and \texttt{strategy} is an expression stating how rules in \texttt{R} are to be performed. We prove that the calculus we introduce is sound. Moreover, we show how the proposed framework can be instantiated successfully with different logics. We investigate first-order logic and several of its decidable fragments with a particular focus on different dialects of description logic (DL). We also show, by using bisimulation relations, that some DL fragments cannot be used due to their lack of expressive power.

cs.LO↗

arXiv2014

Abstracting an operational semantics to finite automata

There is an apparent similarity between the descriptions of small-step operational semantics of imperative programs and the semantics of finite automata, so defining an abstraction mapping from semantics to automata and proving a simulation property seems to be easy. This paper aims at identifying the reasons why simple proofs break, among them artifacts in the semantics that lead to stuttering steps in the simulation. We then present a semantics based on the zipper data structure, with a direct interpretation of evaluation as navigation in the syntax tree. The abstraction function is then defined by equivalence class construction.

cs.PL↗

arXiv2014

SROIQsigma is decidable

We consider a dynamic extension of the description logic $\mathcal{SROIQ}$. This means that interpretations could evolve thanks to some actions such as addition and/or deletion of an element (respectively, a pair of elements) of a concept (respectively, of a role). The obtained logic is called $\mathcal{SROIQ}$ with explicit substitutions and is written $\mathcal{SROIQ^\sigma}$. Substitution is not treated as meta-operation that is carried out immediately, but the operation of substitution may be delayed, so that sub-formulae of $\mathcal{SROIQ}^\sigma$ are of the form $\Phi\sigma$, where $\Phi$ is a $\mathcal{SROIQ}$ formula and $\sigma$ is a substitution which encodes changes of concepts and roles. In this paper, we particularly prove that the satisfiability problem of $\mathcal{SROIQ}^\sigma$ is decidable.

cs.LO↗

arXiv2013

Formal verification of a proof procedure for the description logic ALC

Description Logics (DLs) are a family of languages used for the representation and reasoning on the knowledge of an application domain, in a structured and formal manner. In order to achieve this objective, several provers, such as RACER and FaCT++, have been implemented, but these provers themselves have not been yet certified. In order to ensure the soundness of derivations in these DLs, it is necessary to formally verify the deductions applied by these reasoners. Formal methods offer powerful tools for the specification and verification of proof procedures, among them there are methods for proving properties such as soundness, completeness and termination of a proof procedure. In this paper, we present the definition of a proof procedure for the Description Logic ALC, based on a semantic tableau method. We ensure validity of our prover by proving its soundness, completeness and termination properties using Isabelle proof assistant. The proof proceeds in two phases, first by establishing these properties on an abstract level, and then by instantiating them for an implementation based on lists.

cs.LO↗