First International Workshop on
Component-based Software Development
in Computational Logic (COCL)
Saturday, September 19, 1998 - Pisa (Italy)
Abstracts of the talks
Composing complete and partial knowledge
Sofie Verbaeten (K.U.Leuven, Belgium)
Annalisa Bossi (Universita' Ca' Foscari di Venezia, Italy)
The representation of knowledge in the logic OLP-FOL is split in two
parts: writing definitions for known concepts, and writing constraints,
expressing partial knowledge on other concepts. This is reflected in an
OLP-FOL theory T, which is a pair: T = (T_d, T_c). The definition part
T_d contains the definitions for known predicates in the form of a
normal open logic program (OLP), whereas the first order logic (FOL)
part T_c is a set of FOL axioms, expressing partial knowledge on other
predicates. The semantics of OLP-FOL is a generalisation of the
well-founded semantics. An OLP-FOL theory T = (T_d, T_c), divides the
set of predicate symbols in two disjoint subsets: the defined
predicates, which occur in the head of a clause of T_d, and the open
predicates, which occur at the most in the body of the clauses of T_d.
In previous work, the composition of two OLP-FOL theories, with
non-intersecting sets of defined predicate symbols, was studied. It was
argued that their composition is given by the set of common models.
Here, we investigate the possibility of composing two OLP-FOL theories,
which define the same predicate. Therefore, we introduce two operators
on theories: the p-opening operator, which opens the definition of the
predicate p in a theory completely, and the conditional p-opening
operator, which maintains the definition of p in a theory if a certain
condition holds, and opens p in the other cases. We show that we can
compose two theories, which both have an open definition for the same
predicate, or which both have a conditional open definition for the same
predicate, with non-overlapping conditions.
A functional-logic alternative to monads
Rafael Caballero-Roldan, Francisco J. Lopez-Fraguas
(Universidad Computense de Madrid, Spain)
Monads are a technique widely used in functional programming languages
to address many different problems.
This paper presents extensions, a functional-logic programming
technique that constitutes an alternative to monads in several situations.
Extensions permit the definition of easily reusable functions in the same
way
as monads, but are based on simpler concepts taken from logic programming,
and hence they lead to more appealing and natural definitions of types and
functions.
Moreover, extensions are compatible with interesting features typical of
logic programming, like multiple modes of use, while monads are not. This
property
further contributes to the employment of the same code to solve different
problems.
Towards a Game-based Architecture for developing Complex Interactive Components in Computational Logic
K. Stathis
(Imperial College, London UK)
We present a game-based architecture for developing complex interactive components in
computational logic. This supports the component oriented development of interactive
systems, in such a way, that interactive components can be represented either as players
that make moves according to the rules of
a game or as umpires that enforce the rules on players, and thereby controlling their
interactions. The architecture has already been successfully applied to develop
knowledge-based front-ends to existing software components, including multi-lingual
support for such applications. The potential of the architecture is that centralized
organizations controlled by umpires or decentralized organizations in terms of autonomous
players can be combined to form interactive systems of a very complex nature.
Distribution in a Demand Driven Style
Ian Holyer, Neil Davies and Eleni Spiliopoulou
(University of Bristol, UK)
Many application programs are now distributed. Despite the number of
distribution models, they still suffer from great complexity and therefore lack
resilience and trustability, mainly due to the non-deterministic underlying
communication primitives.
In this paper we present a demand-driven computational model which allows for
arbitrary distribution of computation. This is based on deterministic
concurrency, a purely declarative form of concurrency which
extends the demand driven model of execution of functional languages into one
with multiple independent demands and does not allow non-determinism to appear
at the user level.
The deterministic concurrency approach to distribution leads to a model where
the issue of distribution is orthogonal to the issue of functionality.
Its main characteristic is the high level of trustability in the presence of
distribution which derives from the preservation of referential transparency.
The declarative semantics of a program are not affected, no matter how the
program is distributed.
Furthermore, within this framework, all entities are mobile. Both code and data
can be moved dynamically, on demand.
Using a Modular Distributed Temporal Logic for In-the-large Object
Specification
J. Kuester Filipe
(Technical University Braunschweig, Germany)
Our general goal is to provide a semantic foundation for in-the-large
specification of distributed information systems.
We use TROLL, an object-oriented formal language, for system
specification.
Our claim is that objects are not enough as a modularisation unit when
it comes to deal with very large systems. An intermediary concept between the
system and the objects is needed for allowing reusability of specifications
and provide a clearer system structure.
Enriching TROLL with a module concept enforces us to develop new
theoretical constructs ensuring an appropriate underpinning of the language.
A modular distributed temporal logic MDTL has been developed
which describes the dynamic aspects of modular systems. The main features
of the logic are its own modularity, the ability to express inter-module
(a)synchronous communication and intra-module concurrency. It also seems
promising to support module refinement.
MDTL is based on n-agent logics and interpreted over labelled prime
event structures.
In this paper we present the logic and semantics underlying the modular
object-oriented specification language by means of a small toy example.
Composing Reusable Synthesis Methods through Viewpoints
Jutta Eusterbrock
(University of Aberdeen, Scotland, UK)
To make sense of research on constructive knowledge-based me\-thods
for synthesis tasks, it has to be shown how to reuse and adopt these
results in realistic settings. Cooperative reuse-oriented
heterogenous systems have been proposed as a solution for achieving
high-quality user-friendly systems within changing and distributed
environments. This causes the question, how heterogenous knowledge
resources, application systems and various kinds of synthesis
knowledge, whose informal specifications don`t match with structural
requirements for logic-based constructive reasoning, could be
accessed and used by knowledge-based applications such that logical
properties are being preserved. {\em Viewpoints} are intended to
provide intermediate user-de\-finable independent components between
reasoning components and the domain resources of interest. The
starting point is given by a logical theory, which provides a
generic description of a class of problems by specifying generic
actions, goals and relationships. The definitions serve as initial
elements of a task-specific library of synthesis me\-thods which are
derived as meta-level theorems. A viewpoint is a commitment to
represent domain specific knowledge fragments and problem-solving
knowledge in terms of the vocabulary of an associated generic
theory, such that correctness axioms are preserved. As a major
point, it is proposed to share abstract structure through graphs
rather than to use translations for knowledge integration. It will
be claimed that the viewpoint concept is an adequate means for the
representation of multiple perspectives on distinct semi-structured
domain-specific knowledge resources, making them reusable for
various synthesis applications and synthesis me\-thods reusable in
various settings.
On Specification and Correctness of OOD Frameworks in
Computational Logic
Kung-Kiu Lau
(University of Manchester, UK)
Mario Ornaghi
(Universita' degli studi di Milano, Italy)
In current component-based software development (CBD),
it is widely recognised that the distribution of tasks between
objects and the contracts between them are key to effective design. In
composing designs from reusable parts, increasingly the parts are
Object-oriented Design (OOD) frameworks,
namely descriptions of the interactive relationships between objects which
participate in the interactions. Designs are then built by composing these
frameworks, and any object in the final design will play (various) roles from
several frameworks. In this paper, we discuss our preliminary efforts
to define a formal semantics in computational logic for the specification
and correctness of OOD frameworks, and briefly illustrate it with
frameworks in the CBD methodology Catalysis. The novelty of our approach
is a priori correctness for OOD frameworks (and components in general)
and their composition, in contrast to current development methods
which are mainly in the style of posit-and-prove, whereby proof
of correctness is done by a posteriori verification. For
component-based software development, we argue that a priori
correctness is a better approach than a posteriori correctness.
Back to COCL home page