Title: Generative Modeling by PRISM

Abstract: PRISM is a probabilistic extension of Prolog for modeling complex symbolic systems from Bayesian networks to probabilistic grammars. In this talk, I review the basic structure of the PRISM system from semantics to implementation to statistical inference and explain some of the powerful modeling features with examples.

Title: From Plain Prolog to Logtalk Objects: Effective Code Encapsulation and Reuse

Abstract: Prolog affords concise, elegant, and clean solutions for many interesting problems, but is not immune to the software engineering challenges of large-scale application development. Code modularization, using modules or objects, is a key feature to keep projects manageable. Because most literature, instruction, and practice focus exclusively on object-oriented languages derived from imperative languages, objects are perceived as alien to logic programming while modules are considered a natural fit. Logtalk is an object-oriented logic programming language that can use most Prolog implementations as a back-end compiler. Logtalk objects are about code encapsulation and reuse, creating natural solutions for a wide range of problems that would be awkward to solve using modules. This talk will begin with the Logtalk design goals, followed by a tutorial on Logtalk programming and application examples. The talk will end with the problems and benefits of developing Logtalk as a portable Prolog application.

Title: Experiences using logic programming in bioinformatics

Abstract: Reverse engineering complex biological systems requires the integration of multiple different databases using detailed background knowledge. Logic programming can provide a means of both performing integrative queries and rule-based inference to account for implicit knowledge.

The Biological Logic Programming toolkit (Blipkit) was developed as a means of doing this kind of data integration. Implemented in SWI-Prolog, Blipkit has models of different aspects of life sciences data, including genes and gene sequences, RNA structures, evolutionary relationships, phenotypes and biological interactions. These can be combined to answer complex questions spanning multiple data sources. Blipkit also has means of integrating with and combining life sciences databases and ontologies.

Title: A Knowledge Base System project for FO(.)

Abstract: We will discuss the development of a Knowledge Base (KB) System, for a rich KB language, equipped with several forms of inference able to solve different sorts of tasks using the same KB. The logic FO(.) used in our KBS project is an extension of classical logic with various language primitives such as inductive definitions, aggregates, arithmetic, etc. It is also a natural integration (and further extension) of classical logic and logic programming, based on the view of a logic program as a definition. We discuss informal and formal semantics of definitions in FO(.) and briefly consider the relationship with other knowledge principles such as coinduction, the closed world assumption and causality and with the LP formalisms ASP, ALP and deductive databases. On the computational level, we will report on current attempts to build finite domain inference systems for model expansion, approximate reasoning, theory debugging and model revision, with special focus on the IDP-system, a model expansion system for FO(.) competitive with the best ASP-solvers.

Title: Probabilistic Logic Learning

Abstract: Probabilistic logic learning (PLL) sometimes also called statistical relational learning, addresses one of the central questions of artificial intelligence: the integration of probabilistic reasoning with first order logic representations and machine learning. A rich variety of different formalisms and learning techniques have been developed and they are being applied on applications in network analysis, robotics, bio-informatics, intelligent agents, etc.

This tutorial starts with an introduction to probabilistic representations and machine learning, and then continues with an overview of the state-of-the-art in probabilistic logic learning. We start from classical settings for logic learning (or inductive logic programming) namely learning from entailment, learning from interpretations, and learning from proofs, and show how they can be extended with probabilistic methods. While doing so, we review state-of-the-art probabilistic logic learning approaches.

(The tutorial is -- in part -- based on joint work with Kristian Kersting)

Title: Enabling serendipitous search on the Web of Data using Prolog.

Abstract: The Web of Data, also called the Semantic Web, provides a knowledge representation formalism based on a uniform triple-model: {subject, predicate, object}. A number of more expressive formalisms (e.g., RDFS, OWL, SKOS) are layered on top of the core triple-model. The Web of Data has been developed to represent machine readable knowledge on the internet. Designed to deal with heterogeneous knowledge, the technology underlying the Web of Data is also suitable to unify databases. We use this technology to unify collection information from multiple museums, based on diverse schemas and multiple controlled lists of terms (vocabularies). The resulting knowledge-base is enriched using automatic discovery of mappings between vocabularies. The current challenge is how to provide meaningful services for the end-user based on this knowledge, in particular, how to provide meaningful semantically enriched search?

This tutorial presents the key-components of the Prolog-based ClioPatria toolkit and shows how this infrastructure can be used to explore the opportunities of semantic search. Topics discussed are: reasoning with and editing of RDF models, web-application programming in Prolog combined with AJAX technology and issues when using Prolog for programming `at large'. Prolog is both an RDF query language and a general purpose programming language, and therefore provides a perfect platform for a Semantic Web research and applications.
 

Title: (C)LP tracing and debugging

Abstract: Since Ehud Shapiro's ``Algorithmic debugging'', in 1983, there has been a continuous, even if not very abundant, flow of work on tracing and debugging for (constraint) logic programming. The tutorial will present trace production techniques ranging from compiler instrumentations to dedicated meta-interpreters. It will review work on trace analysis, in particular algorithmic, declarative and rational debugging. It will discuss the issue of trace querying and driving. Last but not least, it will describe the latest software engineering research on trace mining.

Throughout the presentation, we will stress the importance of the nature of the trace data used by the techniques. We will show that CLP techniques have inspired a number of work in other communities. We will argue that trace mining techniques could easily be applied to CLP.
 

Title: Untangling Reverse Engineering with Logic and Abstraction

Abstract: Reverse engineering is the filthy end of the security industry. Hackers, whether white or black, search binaries for vulnerabilities. They do not attempt to reverse assembler into C, which is the traditional aspiration in reversing, but aspire merely understand the code to sufficient depth to manufacture an exploit.This talk will show how logic and abstraction can be being applied to support, and partially automate, this process.