Connectionists: [ICLP 2020] Autumn School on Logic and Constraint Programming - Last Call for Participation

[Laura Pandolfo]

[Apologies for cross-posting]
[Please redistribute]

The organization of the *Autumn School on Logic and Constraint 
Programming* invites you to participate in this year’s school 
(September, 18-19, virtually in Calabria), co-located with ICLP. It 
promises to be an interesting session -- for students, as well as for 
more senior researchers -- in which Marc Denecker discusses the 
*informal semantics* of logic programs (is negation-as-failure actually 
classical?), Peter Stuckey takes on the role of Trojan horse, convincing 
us to use *Minizinc* instead of logic programming, Martin Gebser 
provides unique insights in the magic he uses for tackling *industrial 
applications* with answer set programming, and Elena Bellodi will 
probably talk about *probabilistic logic programming*.

The courses will be run as a hybrid model in which the first two hours 
are thought live, and for the last two hours, a recording will be made 
available.

The abstracts of these talks are included below.

Registration is included in the ICLP registration and can be done via 
https://iclp2020.unical.it/registration (*early bird registration ends 
at September 13th*)

The talks will be a mixture of live sessions and pre-recorded videos. 
More information will be made available on 
https://sites.google.com/view/iclp-dc-2020/autumn-school-on-logic-programming?authuser=0

Spread the word, and we hope to see you soon in virtual Calabria.

Best regards,
Daniela Inclezan, Gopal Gupta, and Bart Bogaerts

--------------------------------

*Martin Gebser (Klagenfurt University): Applications of Answer Set 
Programming*
Abstract: Answer Set Programming (ASP) is a paradigm of knowledge 
representation and reasoning that has become a popular means for 
declarative problem solving. The basic idea is to represent a complex 
application problem by a logic program such that specific 
interpretations, called answer sets, correspond to problem solutions. 
Powerful off-the-shelf ASP systems, such as clingo, dlv and idp, 
automate the problem solving process by first grounding a general 
problem encoding relative to an instance given by facts, and then 
performing Boolean constraint solving to compute (optimal) answer sets.
The application areas of ASP include a variety of domains ranging from 
artificial intelligence, databases, mathematical and scientific fields 
to industrial use cases. For instance, the clingo system has been 
utilized for radio spectrum reallocation in the first-ever incentive 
auction conducted by the Federal Communications Commission, which in 
2016 yielded about 20 billion dollars revenue. Likewise, the dlv system 
has been deployed as a core tool in enterprise software for e-medicine, 
e-tourism, intelligent call routing and workforce management. Last but 
not least, the idp system has been harnessed for interactive 
configuration in the banking sector.
Starting from the expressive modeling language, this tutorial presents 
and illustrates central features making ASP attractive for solving 
application problems. We particularly demonstrate the proficient usage 
of optimization, which is of crucial importance in virtually all 
realistic settings. Beyond traditional single-shot solving, we also 
outline recent advancements in multi-shot solving, driving the 
application of ASP in dynamic areas like automated planning, robotics 
control and stream reasoning.

*Marc Denecker (KU Leuven): On the  informal semantics of knowledge 
representation languages and the case of Logic Programming.*
Abstract: The  informal semantics of a formal language aims to explain 
the ``intuitive'' meaning of the logical symbols, and of the formulas 
and theories of the language. In the context of a KR language, it aims 
to express the knowledge conveyed by formulas and theories about the 
application domain, in a precise and systematic way.  It is a 
controversial concept.  In formal science, one often  avoids to  talk 
about such soft informal topics. For this reason, many may prefer to 
view  a (declarative) formal language as a tool to encode computational 
problems. In that view, the question of its informal ``intuitive'' 
semantics seems of no scientific relevance. Strictly speaking,  the 
meaning of negation as failure is not a scientific question here.
In this course, we will view a formal KR language as a formal study of 
certain types of knowledge. The question of its informal semantics then 
becomes the corner stone of such a study, as it relates the formal 
entities (the formulas) to the informal objects that they intend to 
represent (the knowledge). The  scientific thesis of such a study   is 
then that a formal semantics correctly formalizes the informal 
semantics. The course starts with some considerations on viewing a 
formal language as a  formal study of some forms of knowledge. The 
discussion is based on, a.o., Poppers ideas of formal science. The  goal 
of this discussion is to derive insights  needed to understand the 
current status of informal semantics  in Logic Programming, and 
instruments to analyze it.
In the second part of the lecture, we apply the above ideas and 
instruments on Logic Programming. A brief historical overview is given 
on the topic of informal semantics.  Three main ideas for informal 
semantics were proposed: the Closed World Assumption by Ray Reiter, 
logic programs as definitions by Keith Clark, and the 
(auto)epistemic/default interpretation by Michael Gelfond. We then 
analyze these informal semantics using the instruments introduced in the 
first part: where these informal semantics agree and disagree, how they 
were formalized, how to interpret semantical objects, what is the 
meaning of negation and the rule operator in them and which informal 
semantics applies in the context of concrete examples.
The last part of the lecture is devoted to (inductive) definitions and 
the definitional view of LP. We argue that it is the most precise and 
the most widely applicable. Definitions extend CWA but are more precise 
and more general. They are not equivalent with the epistemic view and 
neither subsumes the other. But there are more applications for 
definitions than for epistemic theories.  In the view of logic programs 
as definitions, we argue that negation is classical but the rule 
operator is not (which confirms what Clark suggested long ago). We 
recall Harel's critique on completion semantics for expressing inductive 
definitions, and give  the proof that in general, inductive definitions 
cannot be expressed  in FO. We discuss the integration of definitional 
knowledge with the knowledge representation paradigm of classical logic, 
as it was done in the logic FO(ID). We end with considering what the 
declarative view of a logic program as a definition can contribute in 
the view of LP as a programming language, as a query language and as a 
KR language.

*Peter Stuckey (Monash University): MiniZinc for high-level 
solver-independent modelling*
Abstract: In this tutorial we will introduce you to modelling discrete 
optimization problems using MiniZinc. MiniZinc allows you to model a 
discrete optimization problem without committing to a particular  solver 
or solver technology.  Thus you can avoid committing to the wrong solver 
technology to your problem. MiniZinc supports Constraint Programming, 
Mixed Integer Programming, Boolean SATisfiability, SAT Modulo Theories 
and Constraint-Based Local Search solvers. The tutorial will cover basic 
modelling, modelling viewpoints, and debugging models. The tutorial will 
involve a series of hands-on tasks using MiniZinc.

*Elena Bellodi (University of Ferrara): Probabilistic Logic Programming*
Abstract: Recently much work in Machine Learning has concentrated on 
representation languages able to combine aspects of logic and 
probability, in order to model domains characterized by both complex and 
uncertain relationships among entities. Machine Learning approaches 
based on such combinations have recently achieved important results, 
originating the fields of Statistical Relational Learning, Probabilistic 
Logic Programming and, more generally, Statistical Relational Artificial 
Intelligence.
The course will concentrate on Probabilistic Logic Programming (PLP), 
which has received an increasing attention for its ability to 
incorporate probability in Logic Programming. Among various proposals 
for PLP, the one based on the distribution semantics has gained 
popularity being at the basis of many PLP languages.
The course will describe syntax and semantics for the main PLP languages 
under the distribution semantics, and overview several systems for 
inference and learning. Then, it will provide an overview of hybrid 
Probabilistic Logic Programs, in which random variables may be both 
discrete and continuous. The course will present the main application 
areas and will include a hands-on experience with the PLP system cplint 
using the web application http://cplint.eu.


-- 

--
*Dona il  5x1000* all'Università degli Studi di Sassaricodice fiscale: 
00196350904
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.srv.cs.cmu.edu/pipermail/connectionists/attachments/20200911/84a112f8/attachment.html>