We have been working on the issue of logic programs updates
(see publications regarding this
line of work).
We have first developed Dynamic Logic Programming
(DLP). According to DLP, knowledge is given by a linearly
ordered sequence of generalized logic programs (i.e.
where default negation may appear both in rule bodies and
heads) that represent distinct and dynamically changing
states of the world. The semantics of DLP ensures that all
previous rules remain valid (by inertia) so long as they
are not contradicted by newer (prevailing) rules. See
these publications for the details.
Recently, we have been working on the integration of
DLP with preferences (see details here).
Whereas DLP provides a declarative semantics for sequences
of programs, it does not provide any natural or pratical
language for the specification of such updates. With such
purpose, we developed LUPS - a language for dynamic
updates. LUPS allows to associate with any given knowledge
state a set of transition or update commands, which
determine what updates should be performed to the current
knowledge state, in order to build a new program in a DLP
sequence. Here are the publications where
you can find the details of LUPS.
DLP has been later extended to allow for multiple
dimensions of updates, defining Multi-dimensional Dynamic
Logic Programming (MDLP) - see corresponding publications
here. DLP allows to encode a
single update dimension, where this dimension can
either be time, hierarchy strength of rules,
priorities, etc. With MDLP more than one of these
dimensions can be dealt with, in a single framework
(allowing e.g. to model the evolution over time of
hierarchycally organized sets of rules). An update
command language (MLUPS) has been recently developed,
that allows for the construction of MDLPs (look
here for details).
We have been working on a general language, christened
EVOLP (after EVOlving Logic Programs), that integrates in a
simple way the concepts of both DLP and LUPS. See here the details of EVOLP. We
have recently generalised EVOLP to deal with temporal operators.
All these languages have been implemented, and the examples
presented in the various papers tested in the
implementations.