A new approach for learning Bayesian belief networks from raw data is presented. The approach is based on Rissanen's Minimal Description Length (MDL) principle, which is particularly well suited for this task. Our approach does not require any prior assumptions about the distribution being learned. In particular, our method can learn unrestricted multiply-connected belief networks. Furthermore, unlike other approaches our method allows us to tradeo accuracy and complexity in the learned model. This is important since if the learned model is very complex (highly connected) it can be conceptually and computationally intractable. In such a case it would be preferable to use a simpler model even if it is less accurate. The MDL principle o ers a reasoned method for making this tradeo. We also show that our method generalizes previous approaches based on Kullback cross-entropy. Experiments have been conducted to demonstrate the feasibility of the approach. Keywords: Knowledge Acquisition � Bayes Nets � Uncertainty Reasoning. 1

We review the linear time suffix tree constructions by Weiner, McCreight, and Ukkonen. We use the terminology of the most recent algorithm, Ukkonen's online construction, to explain its historic predecessors. This reveals relationships much closer than one would expect, since the three algorithms are based on rather different intuitive ideas. Moreover, it completely explains the differences between these algorithms in terms of simplicity, efficiency, and implementation complexity.

In the future, webs of unmanned air and space vehicles will act together to robustly perform elaborate missions in uncertain environments. We coordinate these systems by introducing a reactive model-based programming language (RMPL) that combines within a single unified representation the flexibility of embedded programming and reactive execution languages, and the deliberative reasoning power of temporal planners. The KIRK planning system takes as input a problem expressed as a RMPL program, and compiles it into a temporal plan network (TPN), similar to those used by temporal planners, but extended for symbolic constraints and decisions. This intermediate representation clarifies the relation between temporal planning and causal-link planning, and permits a single task model to be used for planning and execution. Such a

In previous work we developed a method of learning Bayesian Network models from raw data. This method relies on the well known minimal description length (MDL) principle. The MDL principle is particularly well suited to this task as it allows us to tradeoff, in a principled way, the accuracy of the learned network against its practical usefulness. In this paper we present some new results that have arisen from our work. In particular, we present a new local way of computing the description length. This allows us to make significant improvements in our search algorithm. In addition, we modify our algorithm so that it can take into account partial domain information that might be provided by a domain expert. The local computation of description length also opens the door for local refinement of an existent network. The feasibility of our approach is demonstrated by experiments involving networks of a practical size.

We explore the design space of implementing suffix tree algorithms in the functional paradigm. We review the linear time and space algorithms of McCreight and Ukkonen. Based on a new terminology of nested suffixes and nested prefixes, we give a simpler and more declarative explanation of these algorithms than was previously known. We design two "naive" versions of these algorithms which are not linear time, but use simpler data structures, and can be implemented in a purely functional style. Furthermore, we present a new, "lazy" suffix tree construction which is even simpler. We evaluate both imperative and functional implementations of these algorithms. Our results show that the naive algorithms perform very favourably, and in particular, the lazy construction compares very well to all the others. 1 Introduction Suffix trees are the method of choice when a large sequence of symbols, the "text", is to be searched frequently for occurrences of short sequences, the "patterns". Given tha...

We study the development of formally proved algorithms for computational geometry. The result of this work is a formal description of the basic principles that make convex hull algorithms work and two programs that implement convex hull computation and have been automatically obtained from formally verified mathematical proofs. A special attention has been given to handling degenerated cases that are often overlooked by conventional algorithm presentations.

: In this paper, we propose an algorithm for finding all the spanning trees in undirected graphs. The algorithm requires O(n + m + øn) time and O(n + m) space, where the given graph has n vertices, m edges and ø spanning trees. For outputting all the spanning trees explicitly, this algorithm is optimal. 1 Introduction This paper considers a problem for finding all the spanning trees in undirected graphs. This problem has a long history and a lot of algorithms have been proposed (e.g., [4, 5, 9]). In 1975, Read and Tarjan presented an algorithm by using a technique called backtracking [7]. Their algorithm requires O(n +m + øm) time and O(n +m) space, where the given graph has n vertices, m edges and ø spanning trees. In [3], Gabow and Myers refined the backtracking approach and obtained an algorithm with O(n+m+øn) time and O(n+m) space. For outputting all the spanning trees explicitly, this algorithm is optimal. In this paper, we propose an algorithm which generates all the spanning ...

. In this paper, we propose an algorithm for generating all the spanning trees in undirected graphs. The algorithm requires O(n + m + øn) time where the given graph has n vertices, m edges and ø spanning trees. For outputting all the spanning trees explicitly, this time complexity is optimal. Our algorithm follows a special rooted tree structure on the skeleton graph of the spanning tree polytope. The rule by which the rooted tree structure is traversed is irrelevant to the time complexity. In this sense, our algorithm is flexible. If we employ the depth-first search rule, we can save the memory requirement to O(n + m): A breadth-first implementation requires as much as O(m + øn) space, but when a parallel computer is available, this might have an advantage. When a given graph is weighted, the best-first search rule provides a ranking algorithm for the minimum spanning tree problem. The ranking algorithm requires O(n +m + øn) time and O(m + øn) space when we have a minimum spanning tr...

We propose a simple algorithm for lattice point counting in rational polygons. A rational polygon is one whose vertices have rational coordinates. The algorithm decomposes a given polygon into right trapezoids and counts the number of lattice points in the right trapezoids. Each right trapezoid can be dissected into a rectangle and a right-angled triangle in the obvious way. The number of lattice points in the rectangle is easy to determine, and we find that a short recursive function computes the number of lattice points in the right-angled triangle. We also give an algorithm for counting lattice points on line segments.

The efficient management of product-related data is a big challenge for many manufacturing companies, especially the larger ones like DaimlerChrysler. Socalled Product Data Management (PDM) systems are used to tackle this task. But especially in worldwide distributed product development environments, where low bandwidth networks are used, response times of PDM systems often raise to several minutes even for simple user actions. The main reason for this is the amount of wide area network communication caused by poor implementations of PDM systems which a) often use the underlying database management system like a stupid record manager, and b) do hardly know anything about the distribution of the data. In this paper we introduce an extension of directed acyclic graphs which enables us to adequately represent product structures. On the basis of this representation we show how some additional information describing the data distribution can be used to assemble distributed product structures very efficiently. 1