[DL] [ICLP 2020] Autumn School - Call for participation
Laura Pandolfo
lpandolfo at uniss.it
Mon Aug 31 16:55:43 CEST 2020
[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.zfn.uni-bremen.de/pipermail/dl/attachments/20200831/412461db/attachment-0001.htm>
More information about the dl
mailing list