Aachen. Toward Adjoint OpenFOAM. Department of Computer Science. Technical Report. Niloofar Safiran and Uwe Naumann

Transcription

1 Aachen Department of Computer Science Technical Report Toward Adjoint OpenFOAM Niloofar Safiran and Uwe Naumann ISSN Aachener Informatik-Berichte AIB RWTH Aachen Department of Computer Science July

2 The publications of the Department of Computer Science of RWTH Aachen University are in general accessible through the World Wide Web. 2

3 Toward Adjoint OpenFOAM Niloofar Safiran and Uwe Naumann LuFG Informatik 12 - STCE, RWTH Aachen University, Germany {safiran, naumann}@stce.rwth-aachen.de Abstract. OpenFOAM is a package which simplifies the implementation of physical models by mimicking the form of partial differential equations in software. Use of OpenFOAM is rapidly expanding in the research community and among industrial users, covering a wide range of continuum models. AD provides accurate derivative values and better runtime performance of the adjoint model compared with finite differences. This paper presents a transformation of the OpenFOAM code that can be used for calculating derivatives with adjoint mode of AD. An example based on ODE is considered here. 1 Introduction The OpenFOAM (Open Field Operation and Manipulation) CFD Toolbox is a free, open source CFD software package produced by OpenCFD Ltd. It has a large user base across most areas of engineering and science, from both commercial and academic organisations. OpenFOAM has an extensive range of features to solve anything from complex fluid flows involving chemical reactions, turbulence and heat transfer, to solid dynamics and electromagnetics. It includes tools for meshing, a parallelised mesher for pre- and post-processing. The aim of this paper is Applying Algorithmic Differentiation (AD) in OpenFOAM and as result Adjoint OpenFOAM, i.e., calculating the derivative with adjoint mode of algorithmic differentiation by operator overloading (DCO/C++). Here it is shown how to relate DCO/C++ with OpenFOAM and use it to calculate the derivatives of one simple ODE with tangent-linear and adjoint mode AD in OpenFOAM. Calculating the derivatives accurately and efficiently (which AD does) plays a very important role in sensitivity analysis and optimization. 2 ODE in OpenFOAM The main part of ODE solver in OpenFOAM can be found in: $FOAM SRC/ODE For the initial value ODE problem, there are three different kinds of methods in OpenFOAM: RK: Runge-Kutta KRR4: Kaps-Rentrop

4 SIBS: Semi-Implicit Bulirsh-Stoer which can be found in $FOAM SRC/ODE/ODESolvers/: RK/, KRR4/, SIBS/ respectively. In this description, I consider only the KRR4 method. For the system implicit differencing gives y = f(y) (1) y n+1 = y n +hf(y n+1 ) (2) In general this is some nasty set of nonlinear equations that has to be solved iteratively at each step. If we try linearizing the equations as in Newton s method we will have [ y n+1 = y n +h f(y n )+ f ] y.(y n+1 y n ) yn (3) Here f/ y is the matrix of the partial derivatives of the right hand side (the Jacobian matrix). Rearrange equation (3) into the form [ y n+1 = y n +h 1 h f ] 1.f(y n ) (4) y If h is not too big, only one iteration of Newton s method may be accurate enough to solve equation (2) using equation (4). In other words at each step we have to invert the matrix 1 h f y (5) to find y n+1. A Rosenbrock (Kaps-Rentrop) method seeks the solution of the form s y(x 0 +h) = y 0 + c i k i (6) i=1 4

5 where the corrections k i are found by solving s linear equations that generalize the structure in (4): ( (1 γhf ).k i = hf y 0 + i 1 i 1 α ij k j )+hf. γ ij k j, i = 1,...,s (7) j=1 Here we denote the Jacobian matrix by f. The coefficients γ,c i,α ij and γ ij are fixed constants independent of the problem. If γ = γ ij = 0, this is simply a Runge-Kutta scheme. Equation (7) can be solved successively for k 1,k 2,.... Crucial to the success of a stiff integration scheme is an automatic stepsize adjustment which here will be done in ODESolver.C. To minimize the matrix-vector multiplications on the right hand side of the (7), we rewrite the equation in terms of quantities j=1 The equation then takes the form i 1 g i = γ ij k j +γk i (8) j=1 (1/γh f ).g 1 = f(y 0 ) (1/γh f ).g 2 = f(y 0 +a 21 g 1 )+c 21 g 1 /h (1/γh f ).g 3 = f(y 0 +a 31 g 1 +a 32 g 2 )+(c 31 g 1 +c 32 g 2 )/h (1/γh f ).g 4 = f(y 0 +a 41 g 1 +a 42 g 2 +a 43 g 3 )+(c 41 g 1 +c 42 g 2 +c 43 g 3 )/h In the implementation of Kaps-Rentrop algorithm, OpenFOAM provides a routine in the ODE class (in file ODE.H ) called derivatives that returns f (called dydx) as a function of x and y. It also supplies a routine jacobian that returns f (called dfdy) and f/ x (called dfdx) as a function of x and y. (9) 3 Simple ODE Given initial value ODE: y = cos(αx),y(0) = 0 We want to solve our own ODE with OpenFOAM, we will write it in $FOAM APP/ test/ ODETest. At the begining of the code we firstly define the dimension of our ODE: label neqns() const 2{ 5

6 return 1; 4 } Because in our case the order of the ordinary differential equation is 1. Then change our ODE to the first order ODE. y = dydx[0] = cos(αx) void derivatives 2 ( const scalar x, 4 const scalarfield& y, scalarfield& dydx 6 ) const { 8 scalar alpha = 1.0; dydx [0] = cos(alpha x) ; 10 } Then we calculate the Jacobian for both x and y: Suppose f = cos(αx) The Jacobian for x in our case : f x = αsin(αx) The Jacobian for y in our case : f y = 0 void jacobian 2 ( const scalar x, 4 const scalarfield& y, scalarfield& dfdx, 6 scalarsquarematrix& dfdy ) const 8 { scalar alpha = 1.0; 10 dfdx [0] = ( 1) alpha sin (alpha x) ; 12 dfdy [0][0] = 0.0; 14 } 6

7 Finally we define the method of solver and add the initial values in our case and solve our ODE in the main function: int main( int argc, char argv []) 2{ word ODESolverName( KRR4 ) ; 4 testode ode; 6 autoptr<odesolver> odesolver = ODESolver ::New(ODESolverName, ode) ; 8 scalar xstart = 0.0; \\ starting time 10 scalarfield ystart (ode.neqns() ) ; ystart [0] = 0.0; \\ y(0) = 0 12 scalarfield dystart(ode.neqns() ) ; 14 ode. derivatives (xstart, ystart, dystart) ; 16 scalar x = xstart ; scalar xend = x + 1.0; 18 scalarfield y = ystart ; \\ end time 20 scalar hest = 0.001; \\ the time step 22 odesolver >solve (ode, x, xend, y, 1e 4, hest) ; 24 Info << nl << y = << y << endl ; Info << \nend\n << endl ; 26 28} return 0; 2 Then we need to compile the file so that we can run it in OpenFOAM using the linux command wmake. We get: Selecting ODE solver KRR4 y = End If we solve our ODE analytically we can see that: y = cos(αx) y = cos(αx) 7

8 y = cos(αx) = 1 α sin(αx) for α = 1.0 and x : 0 1 : y = sin(1) sin(0) = which is the same as the result we obtained above. 4 Algorithmic Differentiation Algorithmic Differentiation (AD), sometimes alternatively called automatic differentiation, is a method for computing derivatives of output of numerical programs with respect to its inputs both accurately (with machine precision) and efficiently. The two basic modes of AD forward and reverse and combinations thereof yield products of a vector with Jacobian, its transposed, or Hessian respectively. Numerical simulation programs map potentially very large number of input parameters (let there be n) onto often much fewer outputs (say m of them, also refer to as objectives). The classical numerical approach to quantifying the sensitivities of those objectives with respect to the parameters through Finite Difference quotients increase the computational complexity by a factor of O(n). The number of parameters may reach values of the order of n = Hence forward sensitivity analysis would require n runs of the simulation, which is simply not feasible. Reverse (or Adjoint) methods and corresponding program transformation techniques have been developed to replace the dependence on n with that on the number of objectives m. Often the number of objectives is equal to 1. In this case adjoint programs deliver the sensitivities of the objective with respect to all input parameters with an increase in the computational complexity of O(1). Methods of implementation of AD: Overloading STCE tool : dco Source transforming STCE tool : dcc In this paper I will only consider dco. 5 Derivative Code by Overloading Derivative Code by Overloading (DCO/C++) is a developement of the institute Software and Tools for Computational Engineering (LuFG Infomatik 12, RWTH Aachen) implementing AD. The range of capabilities covered by DCO/C++ is deriven by different application research subjects. This paper discusses the application of DCO/C++ in OpenFOAM. The objective is to provide an efficient and robust tool for the computation of the projection of derivatives of arbitrary order of the a function given as an implementation in C/C++. Additionally the capability of coupling the robust overloading technique with optimized computer generated or hand-written external computations of adjoint projection is provided. 8

9 The main idea of DCO/C++ is to use the so-called active variable concept. DCO/C++ provides data types for tangent-linear and adjoint projection. Thereby adjoint projections require an additional data structure for saving data during the forward sweep. This is covered by a tape. The tape can be thought of as directed acyclic graph holding all necessary information for reverse sweep. All data types and tapes are C++-objects inside the namespace dco. Additionally every data type has its own namespace: namespace classes description dco::t1s type tangent-linear 1st-order floating point type dco::a1s type adjoint 1st-order floating point type static tape data structure for propagating adjoints dco::t2s a1s type tangent-linear over adjoint 2nd-order floating point type static tape data structure for propagating 2nd-order adjoints Every data type holds not only a floating point value but also the derivative information, e.g. the tangent-linear type for a variable x must hold the value and also x (1), the adjoint type for a variable x must hold the value and also x (1), etc.. To access those additional components there are set and get routines. Those functions are globally defined in the appropriate namespace. In DCO/C++ the mathematical operators like +,,,/ and standard features such as sin, cos, pow, etc. with their own operators or functions are overwritten. These are desiged so that for each calculation with an active variable the derivative will also be computed. 6 Applying DCO/C++ in OpenFOAM The purpose of this section is to compute the derivative of our ODE (see section 3) with respect to α in OpenFOAM with DCO/C++, i.e., { y = cos(αx) } α} {{ } ODESolver:KRR4 } {{ } DCO/C++ The very first task is to change the data types of the active variables into dco :: t1s :: type (or dco :: a1s :: type) for tangent linear (or adjoint). Here the active variables are: α : which is independent and has scalar type, y : which is dependent and has scalarfield type. In OpenFOAM nearly all of the data types are based on scalar type which is defined on two basic types double and float, in which double type is preput. First of all the definition of the basic type double in OpenFOAM must be found. This definition is in doublescalar.h in $F OAM SRC/OpenF OAM/primitives/Scalar/doubleScalar which has 9

10 the form: typedef double doublescalar; A list of changes that should be done to OpenFOAM are: 1) Add dco.hpp and the related files to $F OAM SRC/OpenF OAM/lnInclude. 2) In $F OAM SRC/OpenF OAM/primitives/Scalar/doubleScalar.H : Include the header file dco.hpp, i.e., #include dco.hpp. Change the typedef double doublescalar to typedef dco::t1s::type doublescalar. Delete the inline functions for hypot, atan2, etc, because all of them are defined in dco.hpp for dco type. Add a function to return the double value of the dco type, later we will see the usage of this function. inline double value ( Scalar s) 2{ return dco :: t1s :: value(s) ; 4} which the dco::t1s::value function is defined in tlm type.hpp and returns the value of the dco type. 3) In $F OAM SRC/OpenF OAM/primitives/Scalar/doubleF loat.h : Include the header file dco.hpp, i.e., #include dco.hpp. Change all double types to dco::t1s::type. 4) In $F OAM SRC/OpenF OAM/primitives/Scalar/Scalar.H : Delete all standard C++ transcendental functions because they are defined in the dco file for dco type. 5) In $F OAM SRC/OpenF OAM/db/IOstreams/IOstreams/IOstreams.H the cast to integer is needed. So we use the function value to change dco::t1s::type to double and then cast it to int : Code: return int (10*num + SMALL); Solution: return int (10* value(num) + value(small)); Code: return int (versionnumber ); Solution: return int (value(versionnumber )); 10

11 Code: return int (10.0 * (versionnumber - majorversion()); Solution: return int (10.0 * (value(versionnumber ) - majorversion()); 6) Eliminating UNARY FUNCTIONS, BINARY TYPE OPERATOR and BesselFunction from all files containing them e.g. from $F OAM SRC/OpenF OAM/f ields/f ields/scalarf ield/scalarf ield.h, because all of the unary functions and binary operators are defined in dco files for dco type. Furthermore, delete the :: at the begining of the functions like abs(), sqrt(), etc, for example: Code: return ::abs(s); Solution: return abs(s); 7) In $F OAM SRC/OpenF OAM/db/IOstream/token/token.H one union is used. DCO/C++ does not support any unoin. Deleting the union will not cause error in the program. 8) In $F OAM SRC/OpenF OAM/db/IOstream/token/tokenI.H delete all functions and variables related to union. 9) In some cases a cast to dco type is needed. For example in $F OAM SRC/lagrangian/basic/P article/p articlei.h: Code : scalar l1 = 0.5 (ap :: sqrt(cp)); scalar l2 = 0.5 (ap+ :: sqrt(cp)); Solution: scalar l1 = scalar( 0.5) (ap sqrt(cp)); scalar l2 = scalar( 0.5) (ap + sqrt(cp)); 10) For simplicity, we comment all of the ODESolvers in $FOAM SRC/ODE/Make/files out except for the Runge-Kutta and KRR4. 11) The goal is to compute y α, so the changes of α should be observed. Therefore, add α to the signature of the solve function. As it is shown in section 3, the dependency of α and y is written in functions derivatives and jacobian, changing also the signature of those functions we will have: 11

12 void derivatives 2 ( const scalar x, 4 const scalarfield& y, scalarfield& dydx, 6 scalar& alpha ) const 8 { 10 dydx [0] = cos(alpha x) ; } void jacobian 2 ( const scalar x, 4 const scalarfield& y, scalarfield& dfdx, 6 scalarsquarematrix& dfdy, scalar& alpha 8 ) const { 10 dfdx [0] = ( 1) alpha sin (alpha x) ; 12 dfdy [0][0] = 0.0; 14 } }; In the jacobian function f/ x and also f/ y are calculated. Another alternative is to use DCO/C++ locally to compute them. This is especially efficient for more comlex equation(s) which the derivatives are not easy to calculate. Theprocess of applyingthe adjoint mode of the DCO/C++ is the same as the tangent-linear mode, the only difference is that instead of dco::t1s::type use dco::a1s::type. For tangent-linear mode the definitions of the set and get routines in the main function are: int main( int argc, char argv []) 2{ word ODESolverName( KRR4 ) ; 4 testode ode; 6 autoptr<odesolver> odesolver = ODESolver ::New(ODESolverName, ode) ; 8 scalar xstart = 0.0; 12

13 scalar alpha = 1.0; 10 scalarfield ystart (ode.neqns() ) ; ystart [0] = 0.0; 12 scalarfield dystart(ode.neqns() ) ; 14 ode. derivatives (xstart, ystart, dystart, alpha) ; 16 scalar x = xstart ; scalar xend = x + 1.0; 18 scalarfield y = ystart ; 20 scalar hest = 0.001; 22 double derivative = 0; 24 dco :: t1s :: set (alpha, 1.0, 1) ; 26 odesolver >solve (ode, x, xend, y, 1e 4, hest, alpha) ; 28 dco :: t1s :: get(y[0], derivative, 1) ; 30 std :: cout << nl << y = << y [0]. v << std :: endl ; std :: cout << nl << Derivative : y = << derivative << std :: endl ; } Info << \nend\n << endl ; return 0; For adjoint mode the definitions of the set and get routines in the main function are: int main( int argc, char argv []) 2{ word ODESolverName( KRR4 ) ; 4 testode ode; 6 autoptr<odesolver> odesolver = ODESolver ::New(ODESolverName, ode) ; 8 scalar xstart = 0.0; scalar alpha = 1.0; 10 scalarfield ystart (ode.neqns() ) ; ystart [0] = 0.0; 12 dco :: a1s :: static tape tape(1e05) ; 14 tape. register variable (alpha) ; 13

14 16 scalarfield dystart(ode.neqns() ) ; ode. derivatives (xstart, ystart, dystart, alpha) ; 18 scalar x = xstart ; 20 scalar xend = x + 1.0; scalarfield y = ystart ; scalar hest = 0.001; double derivative = 0; odesolver >solve (ode, x, xend, y, 1e 4, hest, alpha) ; dco :: a1s :: set (y[0], 1.0, 1); 30 tape. interpret reverse () ; 32 dco :: a1s :: get(alpha, derivative, 1); 34 std :: cout << nl << y = << y [0]. v << std :: endl ; 36 std :: cout << nl << Derivative : y = << derivative << std :: endl ; 38 Info << \nend\n << endl ; 40 return 0; } 12) Running the ODE Library wmake libso ODE in $FOAM SRC. 13) Running our ODETest with wmake. We get: 2 4 Selecting ODE solver KRR4 y = Derivative : y = End In Section 3 the analytical solution of our ODE is shown: y = cos(αx) y = 1 α sin(αx) The derivative with respect to α will be: 14

15 y α = α {1 α sin(αx)} = 1 α 2 sin(αx)+ x α cos(αx) for α = 1.0 and x : 0 1 : { sin(1)+cos(1)} { sin(0)+0} = which is the same as the result we obtained above. 7 Future Work The aim of this paper was computing y α where y is given as solution of ODE to be solved by one of the methods of OpenFOAM s ODESolver. An interesting area of future work is expanding the application of DCO/C++ in all examples and solve functions of OpenFOAM. KRR4 solver requires Jacobian matrix and also f/ x that both can be computed by DCO/C++ locally instead of calculating it manually, because sometimes the functions are so complicated that manual calculation will not be easy. Another opportunity to make the computations more efficiet is that only the data types of active variables are dco types not all of the variables. In this paper actually we define the scalar to be the dco type, although we just needed the dco type for y and α. For this purpose the appropriate unary function and binary operators should also be defined in OpenFOAM. It means that it should differentiate between e.g. cos(scalar a) and cos(active type a). References [1] Exact First- and Second- Order Greeks by Algorithmic Differentiation., NAG Technical Report, TR5/10, The Numerical Algorithm Group ltd [2] U. Naumann. The Art of Differentiating Computer Programs, Introduction, SIAM, 2011, to appear. [3] J. Nocedal and S. J. Wright. Numerical Optimization, Second Edition, Springer Series in Operations Research, [4] A. Griewank and A. Walther. Evaluating Derivatives. Principles and Techniques of Algorithmic Differentiation, Second Edition, SIAM, [5] G.Zongyuan. Introduction to ODE solvers and their application in OpenFOAM, [6] E. Hairer, G. Wanner. Solving Ordinary Differential Equations II, Stiff and Differential-Algebric Problems, Second Edition, Springer, [7] J. Ungermann. Tomographic reconstruction of atmospheric volumes from infrared limb-imager measurements. Diss., Forschungszentrum Juelich, 2011 [8] J. Lotz, K. Leppkes, J. Ungermann, and U. Naumann. Efficient discrete adjoint computation in a spectral simulation code. Technical Report AIB , RWTH Aachen, To appear. [9] K. Leppkes and U. Naumann. dco/c++ Efficient Derivative Code by Overloading in c + +. Technical Report AIB , RWTH Aachen,

16 16

17 Aachener Informatik-Berichte This is the list of all technical reports since To obtain copies of reports please consult or send your request to: Informatik-Bibliothek, RWTH Aachen, Ahornstr. 55, Aachen, Fachgruppe Informatik: Jahresbericht David de Frutos Escrig, Klaus Indermark: Equivalence Relations of Non- Deterministic Ianov-Schemes Manfred Nagl: A Software Development Environment based on Graph Technology Claus Lewerentz, Manfred Nagl, Bernhard Westfechtel: On Integration Mechanisms within a Graph-Based Software Development Environment Reinhard Rinn: Über Eingabeanomalien bei verschiedenen Inferenzmodellen Werner Damm, Gert Döhmen: Specifying Distributed Computer Architectures in AADL* Gregor Engels, Claus Lewerentz, Wilhelm Schäfer: Graph Grammar Engineering: A Software Specification Method Manfred Nagl: Set Theoretic Approaches to Graph Grammars Claus Lewerentz, Andreas Schürr: Experiences with a Database System for Software Documents Herbert Klaeren, Klaus Indermark: A New Implementation Technique for Recursive Function Definitions Rita Loogen: Design of a Parallel Programmable Graph Reduction Machine with Distributed Memory J. Börstler, U. Möncke, R. Wilhelm: Table compression for tree automata Gabriele Esser, Johannes Rückert, Frank Wagner Gesellschaftliche Aspekte der Informatik Peter Martini, Otto Spaniol: Token-Passing in High-Speed Backbone Networks for Campus-Wide Environments Thomas Welzel: Simulation of a Multiple Token Ring Backbone Peter Martini: Performance Comparison for HSLAN Media Access Protocols Peter Martini: Performance Analysis of Multiple Token Rings Andreas Mann, Johannes Rückert, Otto Spaniol: Datenfunknetze Andreas Mann, Johannes Rückert: Packet Radio Networks for Data Exchange AndreasMann, JohannesRückert:ConcurrentSlot AssignmentProtocol for Packet Radio Networks W. Kremer, F. Reichert, J. Rückert, A. Mann: Entwurf einer Netzwerktopologie für ein Mobilfunknetz zur Unterstützung des öffentlichen Straßenverkehrs Kai Jakobs: Towards User-Friendly Networking Kai Jakobs: The Directory - Evolution of a Standard 17

18 Kai Jakobs: Directory Services in Distributed Systems - A Survey Martine Schümmer: RS-511, a Protocol for the Plant Floor U. Quernheim: Satellite Communication Protocols - A Performance Comparison Considering On-Board Processing PeterMartini,OttoSpaniol,ThomasWelzel: FileTransferin HighSpeed Token Ring Networks: Performance Evaluation by Approximate Analysis and Simulation Fachgruppe Informatik: Jahresbericht Wolfgang Thomas: Automata on Infinite Objects Michael Sonnenschein: On Petri Nets and Data Flow Graphs Heiko Vogler: Functional Distribution of the Contextual Analysis in Block-Structured Programming Languages: A Case Study of Tree Transducers Thomas Welzel: Einsatz des Simulationswerkzeuges QNAP2 zur Leistungsbewertung von Kommunikationsprotokollen Th. Janning, C. Lewerentz: Integrated Project Team Management in a Software Development Environment Joost Engelfriet, Heiko Vogler: Modular Tree Transducers Wolfgang Thomas: Automata and Quantifier Hierarchies Uschi Heuter: Generalized Definite Tree Languages Fachgruppe Informatik: Jahresbericht G. Esser, J. Rückert, F. Wagner (Hrsg.): Gesellschaftliche Aspekte der Informatik Heiko Vogler: Bottom-Up Computation of Primitive Recursive Tree Functions Andy Schürr: Introduction to PROGRESS, an Attribute Graph Grammar Based Specification Language J. Börstler: Reuse and Software Development - Problems, Solutions, and Bibliography (in German) Kai Jakobs: OSI - An Appropriate Basis for Group Communication? Kai Jakobs: ISO s Directory Proposal - Evolution, Current Status and Future Problems Bernhard Westfechtel: Extension of a Graph Storage for Software Documents with Primitives for Undo/Redo and Revision Control Peter Martini: High Speed Local Area Networks - A Tutorial P. Davids, Th. Welzel: Performance Analysis of DQDB Based on Simulation Manfred Nagl (Ed.): Abstracts of Talks presented at the WG 89 15th International Workshop on Graphtheoretic Concepts in Computer Science Peter Martini: The DQDB Protocol - Is it Playing the Game? Martine Schümmer: CNC/DNC Communication with MAP Martine Schümmer: Local Area Networks for Manufactoring Environments with hard Real-Time Requirements 18

19 M. Schümmer, Th. Welzel, P. Martini: Integration of Field Bus and MAP Networks - Hierarchical Communication Systems in Production Environments G. Vossen, K.-U. Witt: SUXESS: Towards a Sound Unification of Extensions of the Relational Data Model J. Derissen, P. Hruschka, M.v.d. Beeck, Th. Janning, M. Nagl: Integrating Structured Analysis and Information Modelling A. Maassen: Programming with Higher Order Functions Mario Rodriguez-Artalejo, Heiko Vogler: A Narrowing Machine for Syntax Directed BABEL H. Kuchen, R. Loogen, J.J. Moreno Navarro, M. Rodriguez Artalejo: Graph-based Implementation of a Functional Logic Language Fachgruppe Informatik: Jahresbericht Vera Jansen, Andreas Potthoff, Wolfgang Thomas, Udo Wermuth: A Short Guide to the AMORE System (Computing Automata, MOnoids and Regular Expressions) Jerzy Skurczynski: On Three Hierarchies of Weak SkS Formulas R. Loogen: Stack-based Implementation of Narrowing H. Kuchen, A. Wagener: Comparison of Dynamic Load Balancing Strategies Kai Jakobs, Frank Reichert: Directory Services for Mobile Communication Kai Jakobs: What s Beyond the Interface - OSI Networks to Support Cooperative Work Kai Jakobs: Directory Names and Schema - An Evaluation Ulrich Quernheim, Dieter Kreuer: Das CCITT - Signalisierungssystem Nr. 7 auf Satellitenstrecken; Simulation der Zeichengabestrecke H. Kuchen, R. Loogen, J.J. Moreno Navarro, M. Rodriguez Artalejo: Lazy Narrowing in a Graph Machine Kai Jakobs, Josef Kaltwasser, Frank Reichert, Otto Spaniol: Der Computer fährt mit Rudolf Mathar, Andreas Mann: Analyzing a Distributed Slot Assignment Protocol by Markov Chains A. Maassen: Compilerentwicklung in Miranda - ein Praktikum in funktionaler Programmierung (written in german) Manfred Nagl, Andreas Schürr: A Specification Environment for Graph Grammars A. Schürr: PROGRESS: A VHL-Language Based on Graph Grammars Marita Möller: Ein Ebenenmodell wissensbasierterkonsultationen - Unterstützung für Wissensakquisition und Erklärungsfähigkeit EricKowalewski:EntwurfundInterpretationeinerSprachezurBeschreibung von Konsultationsphasen in Expertensystemen Y. Ortega Mallen, D. de Frutos Escrig: A Complete Proof System for Timed Observations 19

20 Manfred Nagl: Modelling of Software Architectures: Importance, Notions, Experiences H. Fassbender, H. Vogler: A Call-by-need Implementation of Syntax Directed Functional Programming Guenther Geiler (ed.), Fachgruppe Informatik: Jahresbericht B. Steffen, A. Ingolfsdottir: Characteristic Formulae for Processes with Divergence M. Portz: A new class of cryptosystems based on interconnection networks H. Kuchen, G. Geiler: Distributed Applicative Arrays Ludwig Staiger: Kolmogorov Complexity and Hausdorff Dimension Ludwig Staiger: Syntactic Congruences for w-languages Eila Kuikka: A Proposal for a Syntax-Directed Text Processing System K. Gladitz, H. Fassbender, H. Vogler: Compiler-based Implementation of Syntax-Directed Functional Programming R. Loogen, St. Winkler: Dynamic Detection of Determinism in Functional Logic Languages K. Indermark, M. Rodriguez Artalejo (Eds.): Granada Workshop on the Integration of Functional and Logic Programming Rolf Hager, Wolfgang Kremer: The Adaptive PriorityScheduler: A More Fair Priority Service Discipline AndreasFasbender,WolfgangKremer:ANewApproximationAlgorithm for Tandem Networks with Priority Nodes J. Börstler, A. Zündorf: Revisiting extensions to Modula-2 to support reusability J. Börstler, Th. Janning: Bridging the gap between Requirements Analysis and Design A. Zündorf, A. Schürr: Nondeterministic Control Structures for Graph Rewriting Systems Matthias Jarke, John Mylopoulos, Joachim W. Schmidt, Yannis Vassiliou: DAIDA: An Environment for Evolving Information Systems M. Jeusfeld, M. Jarke: From Relational to Object-Oriented Integrity Simplification G. Hogen, A. Kindler, R. Loogen: Automatic Parallelization of Lazy Functional Programs Prof. Dr. rer. nat. Otto Spaniol: ODP (Open Distributed Processing): Yet another Viewpoint H. Kuchen, F. Lücking, H. Stoltze: The Topology Description Language TDL S. Graf, B. Steffen: Compositional Minimization of Finite State Systems R. Cleaveland, J. Parrow, B. Steffen: The Concurrency Workbench: A Semantics Based Tool for the Verification of Concurrent Systems RudolfMathar, JürgenMattfeldt: OptimalTransmissionRangesforMobile Communication in Linear Multihop Packet Radio Networks M. Jeusfeld, M. Staudt: Query Optimization in Deductive Object Bases 20

21 J. Knoop, B. Steffen: The Interprocedural Coincidence Theorem J. Knoop, B. Steffen: Unifying Strength Reduction and Semantic Code Motion T. Margaria: First-Order theories for the verification of complex FSMs B. Steffen: Generating Data Flow Analysis Algorithms from Modal Specifications Stefan Eherer (ed.), Fachgruppe Informatik: Jahresbericht Bernhard Westfechtel: Basismechanismen zur Datenverwaltungin strukturbezogenen Hypertextsystemen S. A. Smolka, B. Steffen: Priority as Extremal Probability Matthias Jarke, Carlos Maltzahn, Thomas Rose: Sharing Processes: Team Coordination in Design Repositories O. Burkart, B. Steffen: Model Checking for Context-Free Processes Matthias Jarke, Klaus Pohl: Information Systems Quality and Quality Information Systems Rudolf Mathar, Jürgen Mattfeldt: Analyzing Routing Strategy NFP in Multihop Packet Radio Networks on a Line Alfons Kemper, Guido Moerkotte: GrundlagenobjektorientierterDatenbanksysteme Matthias Jarke, Manfred Jeusfeld, Andreas Miethsam, Michael Gocek: Towards a logic-based reconstruction of software configuration management Werner Hans: A Complete Indexing Scheme for WAM-based Abstract Machines W. Hans, R. Loogen, St. Winkler: On the Interaction of Lazy Evaluation and Backtracking Matthias Jarke, Thomas Rose: Specification Management with CAD Th. Noll, H. Vogler: Top-down Parsing with Simultaneous Evaluation on Noncircular Attribute Grammars A. Schuerr, B. Westfechtel: Graphgrammatiken und Graphersetzungssysteme(written in german) Graduiertenkolleg Informatik und Technik (Hrsg.): Forschungsprojekte des Graduiertenkollegs Informatik und Technik M. Jarke (ed.): ConceptBase V3.1 User Manual Clarence A. Ellis, Matthias Jarke (Eds.): Distributed Cooperation in Integrated Information Systems - Proceedings of the Third International Workshop on Intelligent and Cooperative Information Systems H. Kuchen, R. Loogen (eds.): Proceedings of the 4th Int. Workshop on the Parallel Implementation of Functional Languages G. Hogen, R. Loogen: PASTEL- A Parallel Stack-Based Implementation of Eager Functional Programs with Lazy Data Structures (Extended Abstract) H. Kuchen, K. Gladitz: Implementing Bags on a Shared Memory MIMD- Machine 21

22 C. Rathsack, S.B. Scholz: LISA - A Lazy Interpreter for a Full-Fledged Lambda-Calculus T.A. Bratvold: Determining Useful Parallelism in Higher Order Functions S. Kahrs: Polymorphic Type Checking by Interpretation of Code M. Chakravarty, M. Köhler: Equational Constraints, Residuation, and the Parallel JUMP-Machine J. Seward: Polymorphic Strictness Analysis using Frontiers (Draft Version) D. Gärtner, A. Kimms, W. Kluge: pi-redˆ+ - A Compiling Graph- Reduction System for a Full Fledged Lambda-Calculus D. Howe, G. Burn: Experiments with strict STG code J. Glauert: Parallel Implementation of Functional Languages Using Small Processes M. Joy, T. Axford: A Parallel Graph Reduction Machine A. Bennett, P. Kelly: Simulation of Multicache Parallel Reduction K. Langendoen, D.J. Agterkamp: Cache Behaviour of Lazy Functional Programs (Working Paper) K. Hammond, S. Peyton Jones: Profiling scheduling strategies on the GRIP parallel reducer S. Mintchev: Using Strictness Information in the STG-machine D. Rushall: An Attribute Grammar Evaluator in Haskell J. Wild, H. Glaser, P. Hartel: Statistics on storage management in a lazy functional language implementation W.S. Martins: Parallel Implementations of Functional Languages D. Lester: Distributed Garbage Collection of Cyclic Structures (Draft version) J.C. Glas, R.F.H. Hofman, W.G. Vree: Parallelization of Branch-and- Bound Algorithms in a Functional Programming Environment S. Hwang, D. Rushall: The nu-stg machine: a parallelized Spineless Tagless Graph Reduction Machine in a distributed memory architecture (Draft version) G. Burn, D. Le Metayer: Cps-Translation and the Correctness of Optimising Compilers S.L. Peyton Jones, P. Wadler: Imperative functional programming(brief summary) W. Damm, F. Liu, Th. Peikenkamp: Evaluation and Parallelization of Functions in Functional + Logic Languages (abstract) M. Kesseler: Communication Issues Regarding Parallel Functional Graph Rewriting Th. Peikenkamp: Charakterizing and representing neededness in functional loginc languages (abstract) H. Doerr: Monitoring with Graph-Grammars as formal operational Models 22

23 J. van Groningen: Some implementation aspects of Concurrent Clean on distributed memory architectures G. Ostheimer: Load Bounding for Implicit Parallelism (abstract) H. Kuchen, F.J. Lopez Fraguas, J.J. Moreno Navarro, M. Rodriguez Artalejo: Implementing Disequality in a Lazy Functional Logic Language H. Kuchen, F.J. Lopez Fraguas: Result Directed Computing in a Functional Logic Language H. Kuchen, J.J. Moreno Navarro, M.V. Hermenegildo: Independent AND-Parallel Narrowing T. Margaria, B. Steffen: Distinguishing Formulas for Free K. Pohl: The Three Dimensions of Requirements Engineering R. Stainov: A Dynamic Configuration Facility for Multimedia Communications Michael von der Beeck: Integration of Structured Analysis and Timed Statecharts for Real-Time and Concurrency Specification W. Hans, St. Winkler: Aliasing and Groundness Analysis of Logic Programs through Abstract Interpretation and its Safety Gerhard Steinke, Matthias Jarke: Support for Security Modeling in Information Systems Design B. Schinzel: Warum Frauenforschung in Naturwissenschaft und Technik A. Kemper, G. Moerkotte, K. Peithner: Object-Orientation Axiomatised by Dynamic Logic Bernd Heinrichs, Kai Jakobs: Timer Handling in High-Performance Transport Systems B. Heinrichs, K. Jakobs, K. Lenßen, W. Reinhardt, A. Spinner: Euro- Bridge: Communication Services for Multimedia Applications C. Gerlhof, A. Kemper, Ch. Kilger, G. Moerkotte: Partition-Based Clustering in Object Bases: From Theory to Practice J. Börstler: Feature-Oriented Classification and Reuse in IPSEN M. Jarke, J. Bubenko, C. Rolland, A. Sutcliffe, Y. Vassiliou: Theories Underlying Requirements Engineering: An Overview of NATURE at Genesis K. Pohl, M. Jarke:Quality Information Systems: Repository Support for Evolving Process Models A. Zuendorf: Implementation of the imperative / rule based language PROGRES P. Koch: Intelligentes Backtracking bei der Auswertung funktionallogischer Programme RudolfMathar,JürgenMattfeldt:ChannelAssignmentinCellularRadio Networks Gerhard Friedrich, Wolfgang Neidl: Constructive Utility in Model-Based Diagnosis Repair Systems P. S. Chen, R. Hennicker, M. Jarke: On the Retrieval of Reusable Software Components 23

24 W. Hans, St.Winkler: Abstract Interpretation of Functional Logic Languages N. Kiesel, A. Schuerr, B. Westfechtel: Design and Evaluation of GRAS, a Graph-Oriented Database System for Engineering Applications Fachgruppe Informatik: Jahresbericht Patrick Shicheng Chen: On Inference Rules of Logic-Based Information Retrieval Systems G. Hogen, R. Loogen: A New Stack Technique for the Management of Runtime Structures in Distributed Environments A. Zündorf: A Heuristic for the Subgraph Isomorphism Problem in Executing PROGRES A. Kemper, D. Kossmann: Adaptable Pointer Swizzling Strategies in Object Bases: Design, Realization, and Quantitative Analysis GraduiertenkollegInformatikundTechnik(Hrsg.):GraduiertenkollegInformatik und Technik Matthias Berger: k-coloring Vertices using a Neural Network with Convergence to Valid Solutions M. Buchheit, M. Jeusfeld, W. Nutt, M. Staudt: Subsumption between Queries to Object-Oriented Databases O. Burkart, B. Steffen: Pushdown Processes: Parallel Composition and Model Checking R. Große-Wienker,O. Hermanns, D. Menzenbach, A. Pollacks,S. Repetzki, J. Schwartz, K. Sonnenschein, B. Westfechtel: Das SUKITS-Projekt: A-posteriori-Integration heterogener CIM-Anwendungssysteme Rudolf Mathar, Jürgen Mattfeldt: On the Distribution of Cumulated Interference Power in Rayleigh Fading Channels O. Maler, L. Staiger: On Syntactic Congruences for omega-languages M. Jarke, St. Eherer, R. Gallersdoerfer, M. Jeusfeld, M. Staudt: ConceptBase - A Deductive Object Base Manager M. Staudt, H.W. Nissen, M.A. Jeusfeld: Query by Class, Rule and Concept M. Jarke, K. Pohl, St. Jacobs et al.: Requirements Engineering: An Integrated View of Representation Process and Domain M. Jarke, K. Pohl: Establishing Vision in Context: Towards a Model of Requirements Processes W. Hans, H. Kuchen, St. Winkler: Full Indexing for Lazy Narrowing W. Hans, J.J. Ruz, F. Saenz, St. Winkler: A VHDL Specification of a Shared Memory Parallel Machine for Babel K. Finke, M. Jarke, P. Szczurko, R. Soltysiak: Quality Management for Expert Systems in Process Control M. Jarke, M.A. Jeusfeld, P. Szczurko: Three Aspects of Intelligent Cooperation in the Quality Cycle Margit Generet, Sven Martin (eds.), Fachgruppe Informatik: Jahresbericht

25 M. Lefering: Development of Incremental Integration Tools Using Formal Specifications P. Constantopoulos,M. Jarke,J. Mylopoulos, Y. Vassiliou: The Software Information Base: A Server for Reuse Rolf Hager, Rudolf Mathar, Jürgen Mattfeldt: Intelligent Cruise Control and Reliable Communication of Mobile Stations Rolf Hager, Peter Hermesmann, Michael Portz: Feasibility of Authentication Procedures within Advanced Transport Telematics Claudia Popien, Bernd Meyer, Axel Kuepper: A Formal Approach to Service Import in ODP Trader Federations P. Peters, P. Szczurko: Integrating Models of Quality Management Methods by an Object-Oriented Repository Manfred Nagl, Bernhard Westfechtel: A Universal Component for the Administration in Distributed and Integrated Development Environments Patrick Horster, Holger Petersen: Signatur- und Authentifikationsverfahren auf der Basis des diskreten Logarithmusproblems A. Schürr: PROGRES, A Visual Language and Environment for PROgramming with Graph REwrite Systems A. Schürr: Specification of Graph Translators with Triple Graph Grammars A. Schürr: Logic Based Programmed Structure Rewriting Systems L. Staiger: Codes, Simplifying Words, and Open Set Condition Bernhard Westfechtel: A Graph-Based System for Managing Configurations of Engineering Design Documents P. Klein: Designing Software with Modula I. Litovsky, L. Staiger: Finite acceptance of infinite words G. Hogen, R. Loogen: Parallel Functional Implementations: Graphbased vs. Stackbased Reduction M. Jeusfeld, U. Johnen: An Executable Meta Model for Re-Engineering of Database Schemas R. Gallersdörfer, M. Jarke, K. Klabunde: Intelligent Networks as a Data Intensive Application (INDIA) M. Mohnen: Proving the Correctness of the Static Link Technique Using Evolving Algebras H. Fernau, L. Staiger: Valuations and Unambiguity of Languages, with Applications to Fractal Geometry M. Jarke, K. Pohl, R. Dömges, St. Jacobs, H. W. Nissen: Requirements Information Management: The NATURE Approach M. Jarke, K. Pohl, C. Rolland, J.-R. Schmitt: Experience-Based Method Evaluation and Improvement: A Process Modeling Approach St. Jacobs,St. Kethers:ImprovingCommunicationand Decision Making within Quality Function Deployment M. Jarke, H. W. Nissen, K. Pohl: Tool Integration in Evolving Information Systems Environments 25

26 O. Burkart, D. Caucal, B. Steffen: An Elementary Bisimulation Decision Procedure for Arbitrary Context-Free Processes Fachgruppe Informatik: Jahresbericht Andy Schürr, Andreas J. Winter, Albert Zündorf: Graph Grammar Engineering with PROGRES Ludwig Staiger: A Tight Upper Bound on Kolmogorov Complexity by Hausdorff Dimension and Uniformly Optimal Prediction Birgitta König-Ries, Sven Helmer, Guido Moerkotte: An experimental study on the complexity of left-deep join ordering problems for cyclic queries Sophie Cluet, Guido Moerkotte: Efficient Evaluation of Aggregates on Bulk Types Sophie Cluet, Guido Moerkotte: Nested Queries in Object Bases Sophie Cluet, Guido Moerkotte: Query Optimization Techniques Exploiting Class Hierarchies Markus Mohnen: Efficient Compile-Time Garbage Collection for Arbitrary Data Structures Markus Mohnen: Functional Specification of Imperative Programs: An Alternative Point of View of Functional Languages Rainer Gallersdörfer, Matthias Nicola: Improving Performance in Replicated Databases through Relaxed Coherency M.Staudt, K.von Thadden: Subsumption Checking in Knowledge Bases G.V.Zemanek, H.W.Nissen, H.Hubert, M.Jarke: Requirements Analysis from Multiple Perspectives: Experiences with Conceptual Modeling Technology M.Staudt, M.Jarke:IncrementalMaintenance ofexternallymaterialized Views P.Peters, P.Szczurko, M.Jeusfeld: Oriented Information Management: Conceptual Models at Work Matthias Jarke, Sudha Ram (Hrsg.): WITS 95 Proceedings of the 5th Annual Workshop on Information Technologies and Systems W.Hans,St.Winkler,F.Saenz:DistributedExecutioninFunctionalLogic Programming Jahresbericht Michael Hanus, Christian Prehofer: Higher-Order Narrowing with Definitional Trees W.Scheufele, G.Moerkotte: Optimal Ordering of Selections and Joins in Acyclic Queries with Expensive Predicates Klaus Pohl: PRO-ART: Enabling Requirements Pre-Traceability Klaus Pohl: Requirements Engineering: An Overview M.Jarke,W.Marquardt:Designand EvaluationofComputer AidedProcess Modelling Tools Olaf Chitil: The Sigma-Semantics: A Comprehensive Semantics for Functional Programs 26

27 S.Sripada: On Entropy and the Limitations of the Second Law of Thermodynamics Michael Hanus (Ed.): Proceedings of the Poster Session of ALP96 - Fifth International Conference on Algebraic and Logic Programming Michael Hanus (Ed.): Proceedings of the Poster Session of ALP 96 - Fifth International Conference on Algebraic and Logic Programming: Introduction and table of contents Ilies Alouini: An Implementation of Conditional Concurrent Rewriting on Distributed Memory Machines Olivier Danvy, Karoline Malmkjær: On the Idempotence of the CPS Transformation Víctor M. Gulías, José L. Freire: Concurrent Programming in Haskell Sébastien Limet, Pierre Réty: On Decidability of Unifiability Modulo Rewrite Systems Alexandre Tessier: Declarative Debugging in Constraint Logic Programming Reidar Conradi, Bernhard Westfechtel: Version Models for Software Configuration Management C.Weise, D.Lenzkes: A Fast Decision Algorithm for Timed Refinement R.Dömges, K.Pohl, M.Jarke, B.Lohmann, W.Marquardt: PRO- ART/CE* An Environment for Managing the Evolution of Chemical Process Simulation Models K.Pohl, R.Klamma, K.Weidenhaupt, R.Dömges, P.Haumer, M.Jarke: A Framework for Process-Integrated Tools R.Gallersdörfer, K.Klabunde, A.Stolz, M.Eßmajor: INDIA Intelligent Networks as a Data Intensive Application, Final Project Report, June H.Schimpe, M.Staudt: VAREX: An Environment for Validating and Refining Rule Bases M.Jarke,M.Gebhardt, S.Jacobs,H.Nissen: Conflict Analysis AcrossHeterogeneous Viewpoints: Formalization and Visualization Manfred A. Jeusfeld, Tung X. Bui: Decision Support Components on the Internet Manfred A. Jeusfeld, Mike Papazoglou: Information Brokering: Design, Search and Transformation P.Peters, M.Jarke: Simulating the impact of information flows in networked organizations Matthias Jarke, Peter Peters, Manfred A. Jeusfeld: Model-driven planning and design of cooperative information systems G.de Michelis, E.Dubois, M.Jarke, F.Matthes, J.Mylopoulos, K.Pohl, J.Schmidt, C.Woo, E.Yu: Cooperative information systems: a manifesto S.Jacobs, M.Gebhardt, S.Kethers, W.Rzasa: Filling HTML forms simultaneously: CoWeb architecture and functionality M.Gebhardt, S.Jacobs: Conflict Management in Design Michael Hanus, Frank Zartmann (eds.): Jahresbericht

28 Johannes Faassen: Using full parallel Boltzmann Machines for Optimization Andreas Winter, Andy Schürr: Modules and Updatable Graph Views for PROgrammed Graph REwriting Systems Markus Mohnen, Stefan Tobies: Implementing Context Patterns in the Glasgow Haskell Compiler S.Gruner: Schemakorrespondenzaxiome unterstützen die paargrammatische Spezifikation inkrementeller Integrationswerkzeuge Matthias Nicola, Matthias Jarke: Design and Evaluation of Wireless Health Care Information Systems in Developing Countries Petra Hofstedt: Taskparallele Skelette für irregulär strukturierte Probleme in deklarativen Sprachen Dorothea Blostein, Andy Schürr: Computing with Graphs and Graph Rewriting Carl-Arndt Krapp, Bernhard Westfechtel: Feedback Handling in Dynamic Task Nets Matthias Nicola, Matthias Jarke: Integrating Replication and Communication in Performance Models of Distributed Databases R. Klamma, P. Peters, M. Jarke: Workflow Support for Failure Management in Federated Organizations Markus Mohnen: Optimising the Memory Management of Higher-Order Functional Programs Roland Baumann: Client/Server Distribution in a Structure-Oriented Database Management System George Botorog: High-Level Parallel Programming and the Efficient Implementation of Numerical Algorithms Fachgruppe Informatik: Jahresbericht Stefan Gruner, Manfred Nagel, Andy Schürr: Fine-grained and Structure-Oriented Document Integration Tools are Needed for Development Processes Stefan Gruner: Einige Anmerkungen zur graphgrammatischen Spezifikation von Integrationswerkzeugen nach Westfechtel, Janning, Lefering und Schürr O. Kubitz: Mobile Robots in Dynamic Environments Martin Leucker, Stephan Tobies: Truth - A Verification Platform for Distributed Systems Matthias Oliver Berger: DECT in the Factory of the Future M. Arnold, M. Erdmann, M. Glinz, P. Haumer, R. Knoll, B. Paech, K. Pohl, J. Ryser, R. Studer, K. Weidenhaupt: Survey on the Scenario Use in Twelve Selected Industrial Projects Th. Lehmann: Geometrische Ausrichtung medizinischer Bilder am Beispiel intraoraler Radiographien M. Nicola, M. Jarke: Performance Modeling of Distributed and Replicated Databases 28

29 AnsgarSchleicher,BernhardWestfechtel,DirkJäger:ModelingDynamic Software Processes in UML W. Appelt, M. Jarke:InteroperableTools for CooperationSupport using the World Wide Web Klaus Indermark: Semantik rekursiver Funktionsdefinitionen mit Striktheitsinformation Jahresbericht F. Huch: Verifcation of Erlang Programs using Abstract Interpretation and Model Checking Extended Version R. Gallersdörfer, M. Jarke, M. Nicola: The ADR Replication Manager María Alpuente, Michael Hanus, Salvador Lucas, Germán Vidal: Specialization of Functional Logic Programs Based on Needed Narrowing W. Thomas (Ed.): DLT 99 - Developments in Language Theory Fourth International Conference Kai Jakobs, Klaus-Dieter Kleefeld: Informationssysteme für die angewandte historische Geographie Thomas Wilke: CTL+ is exponentially more succinct than CTL Oliver Matz: Dot-Depth and Monadic Quantifier Alternation over Pictures Jahresbericht Jens Vöge, Marcin Jurdzinski A Discrete Strategy Improvement Algorithm for Solving Parity Games D. Jäger, A. Schleicher, B. Westfechtel: UPGRADE: A Framework for Building Graph-Based Software Engineering Tools Andreas Becks, Stefan Sklorz, Matthias Jarke: Exploring the Semantic Structure of Technical Document Collections: A Cooperative Systems Approach Mareike Schoop: Cooperative Document Management Mareike Schoop, Christoph Quix(eds.): Proceedings of the Fifth International Workshop on the Language-Action Perspective on Communication Modelling Markus Mohnen, Pieter Koopman (Eds.): Proceedings of the 12th International Workshop of Functional Languages Thomas Arts, Thomas Noll: Verifying Generic Erlang Client-Server Implementations Jahresbericht Benedikt Bollig, Martin Leucker: Deciding LTL over Mazurkiewicz Traces Thierry Cachat: The power of one-letter rational languages Benedikt Bollig, Martin Leucker, Michael Weber: Local Parallel Model Checking for the Alternation Free mu-calculus Benedikt Bollig, Martin Leucker, Thomas Noll: Regular MSC Languages Achim Blumensath: Prefix-Recognisable Graphs and Monadic Second- Order Logic Martin Grohe, Stefan Wöhrle: An Existential Locality Theorem 29