Showing papers in "Acta Informatica in 1980"

Ordered attributed grammars

Abstract: Ordered attributed grammars are defined as a large subclass of semantically well-defined attributed grammars proposed by Knuth. An attributed grammar is ordered if for each symbol a partial order over the associated attributes can be given, such that in any context of the symbol the attributes are evaluable in an order which includes that partial order. The definition does not refer to a predefined strategy for attribute evaluation, e.g. several passes from left to right. For each attributed grammar evaluable by any predefined evaluation strategy such an order exists. The ordering property can be checked by an algorithm, which depends polynomially in time on the size of the input grammar. "Visit-sequences" are computed from the attribute dependencies given by an ordered attributed grammar. They describe the control flow of an algorithm for attribute evaluation which can be part of an automatically generated compiler.

The `Hoare logic' of concurrent programs

Abstract: Hoare's logical system for specifying and proving partial correctness properties of sequential programs is generalized to concurrent programs. The basic idea is to define the assertion {P} S {Q} to mean that if execution is begun anywhere in S with P true, then P will remain true until S terminates, and Q will be true if and when S terminates. The predicates P and Q may depend upon program control locations as well as upon the values of variables. A system of inference rules and axiom schemas is given, and a formal correctness proof for a simple program is outlined. We show that by specifying certain requirements for the unimplemented parts, correctness properties can be proved without completely implementing the program. The relation to Pnueli's temporal logic formalism is also discussed.

Efficient worst-case data structures for range searching

Abstract: In this paper we investigate the worst-case complexity of range searching: preprocess N points in k-space such that range queries can be answered quickly. A range query asks for all points with each coordinate in some range of values, and arises in many problems in statistics and data bases. We develop three different structures for range searching in this paper. The first structure has absolutely optimal query time (which we prove), but has very high preprocessing and storage costs. The second structure we present has logarithmic query time and O(N 1+2) preprocessing and storage costs, for any fixed ?>0. Finally we give a structure with linear storage, O(N ln N) preprocessing and O(N ?) query time.

Approximate analysis of exponential queueing systems with blocking

Abstract: A network of service stations Q 0 Q 1,...,QM is studied. Requests arrive at the centers according to independent Poisson processes; they travel through (part of) the network demanding amounts of service, with independent and negative exponentially distributed lengths, from those centers which they enter, and finally depart from the network. The waiting rooms or buffers at each service station in this exponential service system are finite. When the capacity at Q i is reached, service at all nodes which are currently processing a request destined next for Q i is instantaneously interrupted. The interruption lasts until the service of the request in the saturated node Q i is. completed. This blocking phenomenon makes an exact analysis intractable and a numerical solution computationally infeasible for most exponential systems. We introduce an approximation procedure for a class of exponential systems with blocking and show that it leads to accurate approximations for the marginal equilibrium queue length distributions. The applicability of the approximation method may not be limited to blocking systems.

Concurrent search and insertion in 2---3 trees

Abstract: The problem being addressed is to allow a number of processes to search and insert concurrently in a 2---3 tree without causing deadlock and without destroying the integrity of the data or structure. We present two solutions which allow more concurrency than do previous solutions. Several techniques for introducing parallelism are illustrated. Finally, simulation results used to evaluate the parallel performance of these algorithms are summarized.

An algorithmic and complexity analysis of interpolation search

Abstract: We begin with a brief survey of the literature concerning the Interpolation Search algorithm, then provide a detailed description of the algorithm and how to implement it to search a particular table or file. We next analyze the complexity of the search method by investigating the moments of the distribution of the number of table accesses needed to locate a given record. For a table containing n entries, we find that the expected value of the number of accesses is log2 log2 n+O(1) and that the variance is O(log2 log2 n). Lastly we provide some approximations for the expected value for the successful and unsuccessful search in such a table.

Automaten in planaren Graphen

Abstract: For any finite set of automata there is a planar graph which the automata together cannot search.

Amounts of nondeterminism in finite automata

Abstract: The amount of nondeterminism in a nondeterministic finite automaton (NFA) is measured by counting the minimal number of "guessing points" a string w has to pass through on its way to an accepting state. NFA's with more nondeterminism can achieve greater savings in the number of states over their deterministic counterparts than NFA's with less nondeterminism. On the other hand, for some nontrivial infinite regular languages a deterministic finite automaton (DFA) can already be quite succinct in the sense that NFA's need as many states (and even context-free grammars need as many nonterminals) as the minimal DFA has states.

Some beautiful arguments using mathematical induction

Abstract: Three elegant proofs and an efficient algorithm are derived The derivations evolve smoothly from the choice to apply mathematical induction, the pattern of reasoning that has been chosen as the `Leitmotiv' for this small collection The last proof is the by-product of the algorithm

Analysis of a prioritized CSMA protocol based on staggered delays

Abstract: Carrier sense multiple access (CSMA) protocols were originally conceived for use in digital radio communication. Such protocols are, however, quite applicable in a variety of distributed computing and local networking configurations based on a shared bus. The CSMA protocols are characterized by the fact that message collisions can occur only in a very small time window whose duration corresponds to the propagation delay of the bus. They are further characterized by the technique used to subsequently serialize the transmission of the colliding messages. In this paper we analyze the situation wherein colliding messages are serialized by using a set of staggered `retry' delays which are associated with the sources that may generate the colliding messages. Our analysis produces both path throughput (utilization) curves and message delay curves, as a function of message generation rate. These curves show that the protocol is in a sense self stabalizing, serve to quantify its behaviour, and indicate loading levels which result in unacceptable message delays.

On alternation II

Abstract: Every deterministic t(n)-time bounded multitape Turing machine can be simulated by an alternating t(n) loglog t(n)/log t(n)-time bounded Turing machine. If the depth of every directed acyclic graph with n edges can be reduced to log n by removing only o(n) edges, then in linear time nondeterministic multitape Turing machines can recognize mor languages than deterministic multitape Turing machines. For some graphs reduction of the depth to log n requires the removal of Ω(n/loglog n) edges. A graph theoretic condition is given, which implies that obliviousness reduces the power of multitape Turing machines.

Methods for the automatic construction of error correcting parsers

Abstract: Methods for the automatic construction of error handling parsers are presented. The resulting parsers are capable of correcting all syntax errors by insertion and/or deletion of terminal symbols to the right of the error location. Thus, the output of the parser always corresponds to a syntactically valid program. This contributes significantly to the reliability and robustness of a compiler. The speed of parsing correct parts of a program is not affected by the presence of the error handling capability. The correction algorithm is easy to implement. Apart from the parsing tables only one character per parser state is required to control the correction process. The method is applicable to a wide class of stack automata including LL(k), LR(k), SLR(k), and LALR(k) parsers. It is shown that for LL(k) grammars error correction can be obtained as a byproduct of the canonical LL(k) parser generation. A similar result can be obtained for LR(k) grammars if the parser generator is slightly modified. The method has been successfully added to an LALR(1) parser generator.

Gobang ist PSPACE-vollständig

Abstract: For many games, the decision problem of whether a player in a given situation has a winning strategy has been shown to be PSPACE-complete. Following the PSPACE-completeness results of Even and Tarjan [1] for generalized Hex on graphs and of Schaefer [6] for a variety of combinatorial games, the decision problems were shown to be PSPACE-hard for generalizations of Go and Checkers. In this paper a corresponding theorem is proved for the board-game Gobang, a variant of Go. Since the decision problem for Gobang states-of-play itself lies in PSPACE, it can be shown that Gobang is in fact PSPACE-complete.

Analysis of a service facility with periodic checkpointing

Abstract: This paper is an application of the theory of Markov renewal and semi regenerative processes into checkpointing problems. Its main practical contribution consists in the analytic expression of mean response time of systems under checkpointing and in the presence of intermittent failures (data bases, file systems ...).

Descriptively complete process logic

Abstract: The main purpose of this paper is to contribute to the development of Pratt's [12, 13] process logic by presenting a modest language for this logic in which some reasonably powerful class of connectives is definable. In particular, Parikh's [8] formidable language SOAPL is shown to be interpretable in our new language. Semantically, Pneuli's [9, 10] temporal semantics is incorporated into that of process logic.

First-order identities as a defining language

Abstract: Inverting the adage that a data type is just a simple programming language, we take the position that a programming language is, semantically, just a complex data type; evaluation of a program is just another operation in the data type. The algebraic approach to data types may then be applied. We make a distinction between specification and modelling, and we emphasize the use of first-order identities as a specification language rather than as a tool for model-building. Denotational and operational semantics are discussed. Techniques are introduced for proving the equivalence of specifications. Reynolds' lambda-calculus interpreter is analyzed as an example.

Hierarchical program specification and verification -- a many-sorted logical approach

Abstract: The notion of abstractions in programming is characterized by the distinction between specification and implementation. As far as the specification structures are concerned, hierarchical program development with abstraction mechanisms is naturally regarded as a process of theory extensions in a many-sorted logic. To support such program development, a language called t is proposed with which one can structuredly build up theories and write their program implementation. There, the implementation is regarded as another level of theory extension, and the relation between the specification and the implementation of an abstraction is characterized in terms of a homomorphism between the two theories. On this formalism, a mechanizable proof method is introduced for validation of implementations of both data and procedural abstraction. Finally, a new data type concept is introduced to generalize the so-called type-parametrization mechanism. A justification of this concept within the first order logic is provided as well as its applications to program structuring and verification.

Efficient LL(1) error correction and recovery using only insertions

Abstract: An LL(1)-based error-corrector which operates by insertion-only is studied. The corrector is able to correct and parse any input string. It is efficient (linear in space and time requirements) and chooses least-cost insertions (as defined by the user) in correcting syntax errors. Moreover, the error-corrector can be generated automatically from the grammar and a table of terminal symbol insertion costs. This method is also very well suited for use as an automatic error-recovery technique in LL(1) parsers. The class of LL(1) grammars correctable by this method contains (with minor modifications) grammars used to specify most common programming languages. Preliminary results suggest that this method can be used to advantage in LL(1)-driven compilers.

An O(V5/3E2/3) algorithm for the maximal flow problem

Abstract: A new algorithm for finding a maximal flow in a given network is presented. The algorithm runs in time O(V 5/3 E 2/3), where V and E are the number of the vertices and edges in the network.

Semantic routines and LR(k) parsers

Abstract: Most applications of parsing require that the parser call semantic action routines while processing the input. For LR(k) parsers it is well known that a semantic action routine can be called when the end of a production is recognized. Often, however, it is desirable to call routines at other times. This paper presents fast algorithms that determine, for an LR(k) (or SLR(k)) grammar, which positions are suitable for calling routines. The algorithms are practical for use with LR(1) (SLR(1)) parser building programs, because the worst case running time is dominated by the time required to build the LR(1) (SLR(1)) parser. Applications of the algorithms to attribute grammars and automatic indentation are discussed.

Optimum multiway search trees

Abstract: The construction of optimum multiway search trees for n keys, n key weights and n+1 gap weights, is investigated. A new general optimality principle is presented, which can be "tuned" for specific applications. Moreover we consider the affects of three additional constraints, namely height, structural and node search restrictions, which lead to a number of new construction algorithms. In particular we concentrate on the construction of optimum t-ary search trees with linear and binary search within their nodes for which we obtain O(n 3 t) and O(n 3log2 t) time algorithms, respectively. Whether these algorithms are or are not optimal remains an important open problem, even in the binary case.

Applications of efficient mergeable heaps for optimization problems on trees

Abstract: It is shown how to use efficient mergeable heaps to improve the running time of two algorithms that solve optimization problems on trees.

Memory fragmentation in buddy methods for dynamic storage allocation

Abstract: Methods are presented for the estimation of bounds on the memory fragmentation in buddy methods of dynamic storage allocation. These bounds, when compared with the results of simulation studies, are found to be sufficiently precise to be of considerable practical utility.

A new lower bound on the monotone network complexity of Boolean sums

Abstract: Neciporuk [3], Lamagna/Savage [1] and Tarjan [6] determined the monotone network complexity of a set of Boolean sums if each two sums have at most one variable in common. By this result they could define explicitely a set of n Boolean sums which depend on n variables and whose monotone complexity is of order n 3/2. In the main theorem of this paper we prove a more general lower bound on the monotone network complexity of Boolean sums. Our lower bound is for many Boolean sums the first nontrivial lower bound. On the other side we can prove that the best lower bound which the main theorem yields is the n 3/2-bound cited above. For the proof we use the technical trick of assuming that certain functions are given for free.

On generators and generative capacity of EOL forms

Abstract: In this paper we study the generative capacity of EOL forms from two different points of view. On the one hand, we consider the generative capacity of special EOL forms which one could call `linear like' and `context free like', establishing the existence of a rich variety of non-regular sub-EOL language families. On the other hand, we propose the notion of a `generator' L of a language family ? We mean by this that any synchronized EOL system generating L generates -- if understood as an EOL form -- all languages of ?. We characterize the generators of the family of regular languages, and prove that other well known language families do not have generators.

Remarks on A Synthesis of Several Sorting Algorithms by John Darlington

Abstract: In his paper "A Synthesis of Several Sorting Algorithms," John Darlington presents syntheses for six different sorting algorithms, together with a family tree of sorting algorithms, and mentions a symmetry between Quick Sort, Selection Sort, Merge Sort, and Insertion Sort. In our own attempts to codify programming knowledge, we have developed a slightly different family tree which shows similar symmetries, and which also shows that Bubble Sort and Sinking Sort can be viewed as in-place versions of Selection Sort and Insertion Sort, thus adding another symmetry to those noted by Darlington.

A note on the density of inherently ambiguous context-free languages

Abstract: In this paper we give the first example of an inherently ambiguous context-free language with a non-algebraic density.

On parsing two-level grammars

Abstract: Making use of the fact that two-level grammars (TLGs) may be thought of as finite specification of context-free grammars (CFGs) with "infinite" sets of productions, known techniques for parsing CFGs are applied to TLGs by first specifying a canonical CFG G? -- called skeleton grammar -- obtained from the "cross-reference" of the TLG G. Under very natural restrictions it can be shown that for these grammar pairs (G, G?) there exists a 1 -- 1 correspondence between leftmost derivations in G and leftmost derivations in G?. With these results a straightforward parsing algorithm for restricted TLGs is given.

Context-free grammars with selective rewriting

Abstract: Selective substitution grammars first introduced by Rozenberg are further investigated In particular we study `context-free grammars' with selection, since the original model is too general in its generative power It is shown how the families of context-free, EOL and ETOL languages can be characterized by selective context-free grammars Further the effect of linguistic restrictions on the family of selection languages is investigated Finally, the notion of a universal grammar is investigated in this framework, demonstrating the existence of selection universal grammars under weak conditions on the selection family

Paramodulated connection graphs

Abstract: The connection graph proof procedure of R. Kowalski is extended to the case of equality. The extension is achieved through the introduction of special links connecting those terms that can be paramodulated upon. Completeness and consistency of the resulting proof procedure are shown.