This is the Proceedings of the twelfth Workshop on Answer Set Programming and Other Computing Paradigms (ASPOCP) 2019, which was held in Philadelphia, USA, June 3rd , 2019.

Reasoning semantically in first-order logic is notoriously a challenge. This paper surveys a selection of semantically-guided or model-based methods that aim at meeting aspects of this challenge. For first-order logic we touch upon resolution-based methods, tableaux-based methods, DPLL-inspired methods, and we give a preview of a new method called SGGS, for Semantically-Guided Goal-Sensitive reasoning. For first-order theories we highlight hierarchical and locality-based methods, concluding with the recent Model-Constructing satisfiability calculus.

Despite remarkable advances in automated visual recognition by machines, some visual tasks remain challenging for machines. Fleuret et al. (2011) introduced the Synthetic Visual Reasoning Test (SVRT) to highlight this point, which required classification of images consisting of randomly generated shapes based on hidden abstract rules using only a few examples. Ellis et al. (2015) demonstrated that a program synthesis approach could solve some of the SVRT problems with unsupervised, few-shot learning, whereas they remained challenging for several convolutional neural networks trained with thousands of examples. Here we re-considered the human and machine experiments, because they followed different protocols and yielded different statistics. We thus proposed a quantitative reintepretation of the data between the protocols, so that we could make fair comparison between human and machine performance. We improved the program synthesis classifier by correcting the image parsings, and compared the results to the performance of other machine agents and human subjects. We grouped the SVRT problems into different types by the two aspects of the core characteristics for classification: shape specification and location relation. We found that the program synthesis classifier could not solve problems involving shape distances, because it relied on symbolic computation which scales poorly with input dimension and adding distances into such computation would increase the dimension combinatorially with the number of shapes in an image. Therefore, although the program synthesis classifier is capable of abstract reasoning, its performance is highly constrained by the accessible information in image parsings.

The significant interest in combining logic and probability for reasoning in uncertain, relational domains has led to a multitude of formalisms, inc luding the family of probabilistic logic programming (PLP) languages based on the dis tribution semantics [Sato, 1995] with languages and systems such as PRISM [Sato, 1995], ICL [Poole, 2008], ProbLog [De Raedt et al., 2007; Fierens et al., 2015] and PIT A [Riguzzi and Swift, 2011]. State-of-the-art inference for PLP uses a reduction to weig hted model counting (WMC) [Chavira and Darwiche, 2008], where the dependency structure of the logic program a nd the queries is first transformed into a propositional formula in a suitable form at that supports efficient WMC. While the details of this transformation differ across approaches, a key part of it is determining the relevant ground program with respect t o the queries of interest, i.e., all groundings of rules that contribute to some deriva tion of a query. This grounding step has received little attention, as its cost is domina ted by the cost of constructing the propositional formula in typical PLP benchmarks that op erate on biological, social or hyperlink networks, where formulas are complex. However, it has been observed 1 that the grounding step is the bottleneck that often makes it impossible to apply PLP inference in the context of ontology-based data access over probabilistic data (pOBDA) [Schoenfisch and Stuckenschmidt, 2017; van Bremen et al., 20 19], where determining the relevant grounding explores a large search space, but on ly small parts of this space contribute to the formulas.

Most program induction approaches require predefined, often hand-engineered, background knowledge (BK). To overcome this limitation, we explore methods to automatically acquire BK through multi-task learning. In this approach, a learner adds learned programs to its BK so that they can be reused to help learn other programs. To improve learning performance, we explore the idea of forgetting, where a learner can additionally remove programs from its BK. We consider forgetting in an inductive logic programming (ILP) setting. We show that forgetting can significantly reduce both the size of the hypothesis space and the sample complexity of an ILP learner. We introduce Forgetgol, a multi-task ILP learner which supports forgetting. We experimentally compare Forgetgol against approaches that either remember or forget everything. Our experimental results show that Forgetgol outperforms the alternative approaches when learning from over 10,000 tasks.

Abstract: We present an environment, benchmark, and deep learning driven automated theorem prover for higher-order logic. Higher-order interactive theorem provers enable the formalization of arbitrary mathematical theories and thereby present an interesting, open-ended challenge for deep learning. We provide an open-source framework based on the HOL Light theorem prover that can be used as a reinforcement learning environment. HOL Light comes with a broad coverage of basic mathematical theorems on calculus and the formal proof of the Kepler conjecture, from which we derive a challenging benchmark for automated reasoning. We also present a deep reinforcement learning driven automated theorem prover, DeepHOL, with strong initial results on this benchmark.

Despite ample evidence that our concepts, our cognitive architecture, and mathematics itself are all deeply compositional, few models take advantage of this structure. We therefore propose a radically compositional approach to computational neuroscience, drawing on the methods of applied category theory. We describe how these tools grant us a means to overcome complexity and improve interpretability, and supply a rigorous common language for scientific modelling, analogous to the type theories of computer science. As a case study, we sketch how to translate from compositional narrative concepts to neural circuits and back again.

Standardization of solver input languages has been a main dr iver for the growth of several areas within knowledge representation and reasoning, fostering the exploitation in actual applications. In this document we present the ASP-Core-2 standard input language for Answer Set Programming, which h as been adopted in ASP Competition events since 2013. KEYWORDS: Answer Set Programming, Standard Language, Knowledge Rep resentation and Reasoning, Standardization 2 Calimeri et al. 1 Introduction The process of standardizing the input languages of solvers for knowledge representation and reasoning research areas has been of utmost importance for the growth o f the related research communities: this has been the case for, e.g., the CNF-DIMACS format for SA T, th en extended to describe input formats for Max-SA T and QBF problems, the OPB format for pseudo-Boolean problems, somehow at the intersection between the CNF-DIMACS format and the LP format for Integer L inear Programming, the XCSP3 format for CP solving, SMT -LIB format for SMT solving, and the STRIP S/ PDDL language for automatic planning. The availability of such common input languages have l ed to the development of e ffi cient solvers in di ff erent KR communities, through a series of solver competitio ns that have pushed the adoption of these standards. The availability of e ffi cient solvers, together with a presence of a common interfac e language, has helped the exploitation of these methodologies in appli cations. The same has happened for Answer Set Programming (ASP) (Brew ka et al. 2011), a well-known approach to knowledge representation and reasoning with root s in the areas of logic programming and nonmonotonic reasoning (Gelfond and Lifschitz 1991), through the development of the ASP-Core language (Calimeri et al. 2011). The first ASP-Core version was a rule-based language whose syntax stems from plain Datalog and Prolog, and was a conservative extension t o the non-ground case of the Core language adopted in the First ASP Competition held in 2002 during the D agstuhl Seminar "Nonmonotonic Reasoning, Answer Set Programming and Constraints"

An important class of decidable first-order logic fragments are those satisfying a guardedness condition, such as the guarded fragment (GF). Usually, decidability for these logics is closely linked to the tree-like model property - the fact that satisfying models can be taken to have tree-like form. Decision procedures for the guarded fragment based on the tree-like model property are difficult to implement. An alternative approach, based on restricting first-order resolution, has been proposed, and this shows more promise from the point of view of implementation. In this work, we connect the tree-like model property of the guarded fragment with the resolution-based approach. We derive efficient resolution-based rewriting algorithms that solve the Quantifier-Free Query Answering Problem under Guarded Tuple Generating Dependencies (GTGDs) and Disjunctive Guarded Tuple Generating Dependencies (DisGTGDs). The Query Answering Problem for these classes subsumes many cases of GF satisfiability. Our algorithms, in addition to making the connection to the tree-like model property clear, give a natural account of the selection and ordering strategies used by resolution procedures for the guarded fragment. We also believe that our rewriting algorithm for the special case of GTGDs may prove itself valuable in practice as it does not require any Skolemisation step and its theoretical runtime outperforms those of known GF resolution procedures in case of fixed dependencies. Moreover, we show a novel normalisation procedure for the widely used chase procedure in case of (disjunctive) GTGDs, which could be useful for future studies.

This work investigates if the current neural architectures are adequate for learning symbolic rewriting. Two kinds of data sets are proposed for this research -- one based on automated proofs and the other being a synthetic set of polynomial terms. The experiments with use of the current neural machine translation models are performed and its results are discussed. Ideas for extending this line of research are proposed and its relevance is motivated.