Concept probing has recently garnered increasing interest as a way to help interpret artificial neural networks, dealing both with their typically large size and their subsymbolic nature, which ultimately renders them unfeasible for direct human interpretation. Concept probing works by training additional classifiers to map the internal representations of a model into human-defined concepts of interest, thus allowing humans to peek inside artificial neural networks. Research on concept probing has mainly focused on the model being probed or the probing model itself, paying limited attention to the data required to train such probing models. In this paper, we address this gap. Focusing on concept probing in the context of image classification tasks, we investigate the effect of the data used to train probing models on their performance. We also make available concept labels for two widely used datasets.

Concept probing has recently gained popularity as a way for humans to peek into what is encoded within artificial neural networks. In concept probing, additional classifiers are trained to map the internal representations of a model into human-defined concepts of interest. However, the performance of these probes is highly dependent on the internal representations they probe from, making identifying the appropriate layer to probe an essential task. In this paper, we propose a method to automatically identify which layer’s representations in a neural network model should be considered when probing for a given human-defined concept of interest, based on how informative and regular the representations are with respect to the concept. We validate our findings through an exhaustive empirical analysis over different neural network models and datasets.

Generalization is an important ability that allows humans to tackle complex problems by identifying common problem structures and omitting irrelevant details. Whereas such ability comes naturally to humans, it has proved challenging to establish within AI systems. Although different research communities have tackled this challenge, their focus has usually been set on developing efficient algorithms for concrete problems, and a general theoretical understanding of the generalization ability is still lacking. In the context of Answer Set Programming (ASP), a well-established knowledge representation and reasoning paradigm for solving highly combinatorial search problems, research on generalization has primarily focused on forgetting and projection, two related operations that aim at the omission of irrelevant details, while abstraction, an operation that aims at providing a higher-level view on the common solution and problem structures, has largely been overlooked. In this paper, we develop the theoretical foundation for generalized reasoning through abstraction in ASP, focusing on the notion of abstraction through vocabulary clustering. We formally characterize when abstraction is possible, semantically define the desired result, investigate syntactic operators to obtain such abstractions, and study the computational complexity of this problem.

Boolean regulatory networks are used to represent complex biological processes, modelling the interactions of biological compounds, such as proteins or genes, with each other and with other substances in a cell. Creating and maintaining computational models of these networks is crucial for comprehending corresponding cellular processes, as they allow reproducing known behaviours and testing new hypotheses and predictions in silico. In this context, model revision focuses on validating and (if necessary) repairing existing models based on new experimental data. However, model revision is commonly performed manually, which is inefficient and prone to error, and the few existing automated solutions either only apply to simpler networks or are limited in their revision process, since they may not be able to produce a solution within a reasonable time frame or miss the optimal solution. In this paper, we develop a solution for revising logical models of Boolean regulatory networks, able to find repairs that are consistent with provided, possibly incomplete experimental data, and minimal w.r.t. the differences to the original network. We show that our solution can be used to revise different real-world Boolean logical models very efficiently, surpassing a previous solution in terms of solved instances and with a considerable margin w.r.t. processing time.

Abstract Forgetting – or variable elimination – is an operation that allows the removal, from a knowledge base, ofmiddlevariables no longer deemed relevant. In recent years, many different approaches for forgetting in Answer Set Programming have been proposed, in the form of specific operators, or classes of such operators, commonly following different principles and obeying different properties. Each such approach was developed to address some particular view on forgetting, aimed at obeying a specific set of properties deemed desirable in such view, but a comprehensive and uniform overview of all the existing operators and properties is missing. In this article, we thoroughly examine existing properties and (classes of) operators for forgetting in Answer Set Programming, drawing a complete picture of the landscape of these classes of forgetting operators, which includes many novel results on relations between properties and operators, including considerations on concrete operators to compute results of forgetting and computational complexity. Our goal is to provide guidance to help users in choosing the operator most adequate for their application requirements.

Abstract Over the last couple of decades, there has been a considerable effort devoted to the problem of updating logic programs under the stable model semantics (a.k.a. answer-set programs) or, in other words, the problem of characterising the result of bringing up-to-date a logic program when the world it describes changes. Whereas the state-of-the-art approaches are guided by the same basic intuitions and aspirations as belief updates in the context of classical logic, they build upon fundamentally different principles and methods, which have prevented a unifying framework that could embrace both belief and rule updates. In this paper, we will overview some of the main approaches and results related to answer-set programming updates, while pointing out some of the main challenges that research in this topic has faced.

Neural networks have been the key to solve a variety of different problems. However, neural network models are still regarded as black boxes, since they do not provide any human-interpretable evidence as to why they output a certain result. We address this issue by leveraging on ontologies and building small classifiers that map a neural network model's internal state to concepts from an ontology, enabling the generation of symbolic justifications for the output of neural network models. Using an image classification problem as testing ground, we discuss how to map the internal state of a neural network to the concepts of an ontology, examine whether the results obtained by the established mappings match our understanding of the mapped concepts, and analyze the justifications obtained through this method.

Modular programming facilitates the creation and reuse of large software, and has recently gathered considerable interest in the context of Answer Set Programming (ASP). In this setting, forgetting, or the elimination of middle variables no longer deemed relevant, is of importance as it allows one to, e.g., simplify a program, make it more declarative, or even hide some of its parts without affecting the consequences for those parts that are relevant. While forgetting in the context of ASP has been extensively studied, its known limitations make it unsuitable to be used in Modular ASP. In this paper, we present a novel class of forgetting operators and show that such operators can always be successfully applied in Modular ASP to forget all kinds of atoms – input, output and hidden – overcoming the impossibility results that exist for general ASP. Additionally, we investigate conditions under which this class of operators preserves the module theorem in Modular ASP, thus ensuring that answer sets of modules can still be composed, and how the module theorem can always be preserved if we further allow the reconfiguration of modules.

Abstract Whereas the operation of forgetting has recently seen a considerable amount of attention in the context of Answer Set Programming (ASP), most of it has focused on theoretical aspects, leaving the practical issues largely untouched. Recent studies include results about what sets of properties operators should satisfy, as well as the abstract characterization of several operators and their theoretical limits. However, no concrete operators have been investigated. In this paper, we address this issue by presenting the first concrete operator that satisfies strong persistence – a property that seems to best capture the essence of forgetting in the context of ASP – whenever this is possible, and many other important properties. The operator is syntactic, limiting the computation of the forgetting result to manipulating the rules in which the atoms to be forgotten occur, naturally yielding a forgetting result that is close to the original program.

The fourteenth International Workshop on Computational Logic in Multi-Agent Systems (CLIMA XIV) was held in Coruña, Spain, 16–18 September 2013. The final programme included 23 papers and 30 participants attended the workshop. This special issue contains six papers from the workshop that discuss a variety of issues central to the use of logic in reasoning about multi-agent systems. The first paper in the collection, ‘The Equivalence Zoo for Dung-style Semantics’ by Baumann and Brewka, presents an extensive study of seven equivalence notions (standard, normal, strong, weak, and local expansion and minimal change equivalence) under major semantics of Dung's argumentation framework (stable, preferred, admissible and complete semantics). It shows that minimal change equivalence is a reasonable notion of equivalence between argumentation frameworks. The paper also investigates the aforementioned relationship with respect to the two restricted classes of argumentation frameworks that have the same arguments and/or are self-loop-free. The second paper, ‘Two-stage Agent Program Verification’ by Dennis, Fisher and Webster, proposes a novel method for verification of agent programs that are written in a Belief–Desire–Intention (BDI) programming language using program model-checkers. The paper extends the Agent Java Pathfinder (AJPF) agent program model-checker to generate models that could be used by other model-checkers. The key idea behind the approach lies in that generated models could be used for several purposes (e.g. proving different properties of a program). The paper demonstrates the new technique by describing the export of the AJPF program models to both the SPIN and P rism model-checkers.

Abstract Among the myriad of desirable properties discussed in the context of forgetting in Answer Set Programming,strong persistencenaturally captures its essence. Recently, it has been shown that it is not always possible to forget a set of atoms from a program while obeying this property, and a precise criterion regarding what can be forgotten has been presented, accompanied by a class of forgetting operators that return the correct result when forgetting is possible. However, it is an open question what to do when we have to forget a set of atoms, but cannot without violating this property. In this paper, we address this issue and investigate three natural alternatives to forget when forgetting without violating strong persistence is not possible, which turn out to correspond to the different possible relaxations of the characterization of strong persistence. Additionally, we discuss their preferable usage, shed light on the relation between forgetting and notions of relativized equivalence established earlier in the context of Answer Set Programming, and present a detailed study on their computational complexity.

Selectively forgetting information while preserving what matters the most is becoming an increasingly important issue in many areas, including in knowledge representation and reasoning. Depending on the application at hand, forgetting operators are defined to obey different sets of desirable properties. Of the myriad of desirable properties discussed in the context of forgetting in Answer Set Programming, strong persistence, which imposes certain conditions on the correspondence between the answer sets of the program pre-and post-forgetting, and a certain independence from non-forgotten atoms, seems to best capture its essence, and be desirable in general. However, it has remained an open problem whether it is always possible to forget a set of atoms from a program while obeying strong persistence. In this paper, after showing that it is not always possible to forget a set of atoms from a program while obeying this property, we move forward and precisely characterise what can and cannot be forgotten from a program, by presenting a necessary and sufficient criterion. This characterisation allows us to draw some important conclusions regarding the existence of forgetting operators for specific classes of logic programs, to characterise the class of forgetting operators that achieve the correct result whenever forgetting is possible, and investigate the related question of determining what we can forget from some specific logic program.

In this paper we present a novel iterative algorithm – the Iterative Successive Substitution (ISS) – to efficiently approximate the models of debates structured according to Social Abstract Argumentation [10]. Classical iterative algorithms such as the Iterative Newton-Raphson (INR) and the Iterative Fixed-point (IFP) don't always converge and, when they do, usually take too long to be effective. We analytically prove convergence of ISS, and empirically show that, even when INR and IFP converge, ISS always outperforms them, often by several orders of magnitude. The ISS is able to approximate the models of complex debates with thousands of arguments in well under a second, often in under one tenth of a second, making it comfortably suitable for its purpose. Additionally, we present a small modification to ISS that, with a negligible overhead, takes advantage of the topological structure of certain debates to significantly increase convergence times.

Managed Multi-Context Systems (mMCSs) provide a general framework for integrating knowledge represented in heterogeneous KR formalisms. However, mMCSs are essentially static as they were not designed to run in a dynamic scenario. In this paper, we introduce evolving Multi-Context Systems (eMCSs), a general and flexible framework which inherits from mMCSs the ability to integrate knowledge represented in heterogeneous KR formalisms, and at the same time is able to both react to, and reason in the presence of commonly temporary dynamic observations, and evolve by incorporating new knowledge. We show that eMCSs are indeed very general and expressive enough to capture several existing KR approaches that model dynamics of knowledge.

In open environments, agents need to reason with knowledge from various sources, represented in different languages. Multi-Context Systems (MCSs) allow for the integration of knowledge from different heterogeneous sources in an effective and modular way. Whereas most knowledge bases (contexts) typically considered within an MCS are written in some description logic or some non-monotonic rule-based language, sometimes more expressive languages that combine the features of both these paradigms are necessary, such as Hybrid MKNF. However, since agents may not have access to specialized reasoners for contexts using all these languages, it proves useful to have tools that equivalently simplify or transform a given MCS into another MCS that only uses the reasoners that are available. In this article, we thoroughly investigate the relation between MCSs and Hybrid MKNF. We provide a number of transformations that show that Hybrid MKNF knowledge bases can be embedded into MCSs without the need for specific MKNF reasoners. To complete the picture, we also show that when an MKNF reasoner is available, it can be used to handle several description logic and rule contexts joined into a single MKNF context. Furthermore, we show that we can encapsulate the non-monotonic transfer of information between different contexts in one rule language context, allowing e.g. the use of external non-monotonic reasoners.

João Leite, Paolo Torroni, Thomas Ågotnes, Guido Boella, Leendert van der Torre; Preface to the Special Issue on Computational Logic in Multi-Agent Systems (CLI

Abstract Logic programs under the stable model semantics, or answer-set programs, provide an expressive rule-based knowledge representation framework, featuring a formal, declarative and well-understood semantics. However, handling the evolution of rule bases is still a largely open problem. The Alchourrón, Gärdenfors and Makinson (AGM) framework for belief change was shown to give inappropriate results when directly applied to logic programs under a non-monotonic semantics such as the stable models. The approaches to address this issue, developed so far, proposed update semantics based on manipulating the syntactic structure of programs and rules. More recently, AGM revision has been successfully applied to a significantly more expressive semantic characterisation of logic programs based onSE-models. This is an important step, as it changes the focus from the evolution of a syntactic representation of a rule base to the evolution of its semantic content. In this paper, we borrow results from the area of belief update to tackle the problem of updating (instead of revising) answer-set programs. We prove a representation theorem which makes it possible to constructively define any operator satisfying a set of postulates derived from Katsuno and Mendelzon's postulates for belief update. We define a specific operator based on this theorem, examine its computational complexity and compare the behaviour of this operator with syntactic rule update semantics from the literature. Perhaps surprisingly, we uncover a serious drawback of all rule update operators based on Katsuno and Mendelzon's approach to update and onSE-models.

Abstract Over the years, nonmonotonic rules have proven to be a very expressive and useful knowledge representation paradigm. They have recently been used to complement the expressive power of Description Logics (DLs), leading to the study of integrative formal frameworks, generally referred to ashybrid knowledge bases, where both DL axioms and rules can be used to represent knowledge. The need to use these hybrid knowledge bases in dynamic domains has called for the development of update operators, which, given the substantially different way DLs and rules are usually updated, has turned out to be an extremely difficult task. In Slota and Leite (2010b Towards Closed World Reasoning in Dynamic Open Worlds.Theory and Practice of Logic Programming, 26th Int'l. Conference on Logic Programming (ICLP'10) Special Issue10(4–6) (July), 547–564.), a first step towards addressing this problem was taken, and an update operator for hybrid knowledge bases was proposed. Despite its significance—not only for being the first update operator for hybrid knowledge bases in the literature, but also because it has some applications—this operator was defined for a restricted class of problems where only the ABox was allowed to change, which considerably diminished its applicability. Many applications that use hybrid knowledge bases in dynamic scenarios require both DL axioms and rules to be updated. In this paper, motivated by real world applications, we introduce an update operator for a large class of hybrid knowledge bases where both the DL component as well as the rule component are allowed to dynamically change. We introduce splitting sequences and splitting theorem for hybrid knowledge bases, use them to define a modular update semantics, investigate its basic properties, and illustrate its use on a realistic example about cargo imports.

Logic programs under the stable models semantics, or answer-set programs, provide an expressive rule based knowledge representation framework, featuring formal, declarative and well-understood semantics. However, handling the evolution of rule bases is still a largely open problem. The AGM framework for belief change was shown to give inappropriate results when directly applied to logic programs under a nonmonotonic semantics such as the stable models. Most approaches to address this issue, developed so far, proposed update operators based on syntactic conditions for rule rejection.

Abstract The need for integration of ontologies with nonmonotonic rules has been gaining importance in a number of areas, such as the Semantic Web. A number of researchers addressed this problem by proposing a unified semantics forhybrid knowledge basescomposed of both an ontology (expressed in a fragment of first-order logic) and nonmonotonic rules. These semantics have matured over the years, but only provide solutions for the static case when knowledge does not need to evolve. In this paper we take a first step towards addressing the dynamics of hybrid knowledge bases. We focus on knowledge updates and, considering the state of the art of belief update, ontology update and rule update, we show that current solutions are only partial and difficult to combine. Then we extend the existing work on ABox updates with rules, provide a semantics for such evolving hybrid knowledge bases and study its basic properties. To the best of our knowledge, this is the first time that an update operator is proposed for hybrid knowledge bases.

User modeling and personalization are the key aspects of recommender systems in terms of recommendation quality. ERASP is an add-on to existing recommender systems which uses dynamic logic programming -- an extension of answer set programming -- as a means for users to specify and update their models and preferences, with the purpose of enhancing recommendations. While being an excellent solution in recommender systems limited to a few thousand products, ERASP does not scale well beyond that point. In this paper we present a major theoretical redesign of ERASP which entails a significant improvement in the performance of its implementation, making it usable in domains with hundreds of thousands of products.