Replace this file with prentcsmacro.sty for your meeting, or with entcsmacro.sty for your meeting. Both can be

Abstract A formalism for constructing database schemata from simple components is presented in which the components are coupled to one another via communicating views. The emphasis is upon identifying the conditions under which such components can be interconnected in a conflict-free fashion, and a characterization of such, based upon the acyclicity of an underlying hypergraph, is obtained. The work is furthermore oriented towards an understanding of how updates can be supported within the component-based framework, and initial ideas of so-called canonical liftings are presented. 1.

Abstract. It is well known that the complexity of testing the correctness of an arbitrary update to a database view can be far greater than the complexity of testing a corresponding update to the main schema. However, views are generally managed according to some protocol which limits the admissible updates to a subset of all possible changes. The question thus arises as to whether there is a more tractable relationship between these two complexities in the presence of such a protocol. In this paper, this question is answered in the affirmative for closed update strategies, which are based upon the constant-complement approach of Bancilhon and Spyratos. Working within a very general framework which is independent of any particular data model, but which recaptures relational schemata constrained by so-called equality-generating dependencies (EGDs), (which include functional dependencies (FDs)), it is shown that the complexity of testing the correctness of a view update which follows a closed update strategy is no greater than that of testing a corresponding update to the main schema. In particular, if the main schema is relational and constrained by FDs, then there exists a set of FDs on the view, against which any candidate update may be tested for correctness. This holds even though the entire view may not be finitely axiomatizable, much less constrained by FDs alone. 1

Abstract. Type hierarchies which arise in applications are often described incompletely; this missing information may be handled in a variety of ways. In this work, such incomplete hierarchies are viewed as open specifications; that is, descriptions which are sets of constraints. The actual hierarchy is then any structure satisfying these constraints. For such specifications, two forms of characterization are provided. The first is algebraic and utilizes a generalization of weak partial lattices; it provides a structure-based characterization in which optimality is characterized via an initial construction. The second is logical, an inference-based representation, in which models are characterized as products of models of propositional-based specifications. 1.

. We present a full proof of a canonical system for adjunctions as already suggested in [Cur93]. Termination can be shown in a similar style to [HL86]. Confluence is shown by checking all critical pairs. This is done firstly in the Larch Prover [GG91] and secondly more correctly in the programming language Elf [Pfe89]. Exploiting theorems from category theory [BW85] this system can be used to solve the uniform word problem for monads. The resulting decision procedure is finally implemented in Elf. 1 Introduction A general problem in category theory is to check the commutativity of certain diagrams where diagrams are nothing but a compact encoding and visualization of equations involving morphisms. In [FS90] one can even find a suitable graphical language. Checking the commutativity means to check the equality of morphisms in a given category. To support this process one can solve the uniform word problem for this category which is of course not always possible having the halting probl...

We introduce MD-sketches, which are a particular kind of Finite Sum sketches. Two interesting results about MD-sketches are proved. First, we show that, given two MD-sketches, it is algorithmically decidable whether their model categories are equivalent. Next we show that data-specifications, as used in database-design and software engineering, can be translated to MD-sketches. As a corollary, we obtain that equivalence of data-specifications is decidable.

Abstract not found

3.97> v m (ph) = 1, p.51. Newbasax def = (Basaxnf Ax6; Ax3;AxE g)[f Ax6 00 ; Ax6 01 ; Ax3 0 ; AxE 0 g = f Ax1;Ax2;Ax3 0 ; Ax4;Ax5;Ax6 00 ; Ax6 01 ; AxE 0 g (cf. p.191), where: Ax6 00 (8m; k 2 Obs) wm [tr m (k)] Rng(w k ), p.190. Intuitively, observer k sees all those events which are seen by another observer m on k's life-line. Ax6 01 (8m; k

Abstract Aformalism forconstructing database schematafromsimplecomponents is presented in which the components are coupled to one another via communicating views. The emphasis is upon identifying the conditions under which such components can be interconnected in a conflict-free fashion, and a characterization of such, based upon the acyclicity of an underlying hypergraph, is obtained. The work is furthermore oriented towards an understanding of how updates can be supported within the component-based framework, and initial ideas of so-called canonical liftings are presented. 1.

Effects are a powerful and convenient component of programming. They enable programmers to interact with the user, take advantage of efficient stateful memory, throw exceptions, and nondeterministically execute programs in parallel. However, they also complicate every aspect of reasoning about a program or language, and as a result it is crucially important to have a good understanding of what effects are and how they work. In this paper we present a new framework for formalizing the semantics of effects that is more general and thorough than previous techniques while clarifying many of the important concepts. By returning to the categorytheoretic roots of monads, our framework is rich enough to describe the semantics of effects for a large class of languages including common imperative and functional languages. It is also capable of capturing more expressive, precise, and practical effect systems than previous approaches. Finally, our framework enables one to reason about effects in a language-independent manner, and so can be applied to many stages of language design and implementation in order to create more broadly applicable tools for programming languages. 1.