scispace - formally typeset
Search or ask a question

Showing papers in "Acta Informatica in 1998"


Journal ArticleDOI
TL;DR: A survey on results related to scheduling problems where machines are not continuously available for processing, NP-hardness results, polynomial optimization and approximation algorithms, and single and multi machine problems.
Abstract: We will give a survey on results related to scheduling problems where machines are not continuously available for processing. We will deal with single and multi machine problems and analyze their complexity. We survey NP-hardness results, polynomial optimization and approximation algorithms. We also distinguish between on-line and off-line formulations of the problems. Results are concerned with criteria on completion times and due dates.

224 citations


Journal ArticleDOI
TL;DR: Several types of sticker systems are shown to characterize (modulo a weak coding) the regular languages, hence the power of finite automata, and one variant is proven to be equivalent to Turing machines.
Abstract: We introduce the sticker systems, a computability model, which is an abstraction of the computations using the Watson-Crick complementarity as in Adleman's DNA computing experiment, [1]. Several types of sticker systems are shown to characterize (modulo a weak coding) the regular languages, hence the power of finite automata. One variant is proven to be equivalent to Turing machines. Another one is found to have a strictly intermediate power.

110 citations


Journal ArticleDOI
TL;DR: A notion of causal bisimulation is proposed which distinguishes processes which differ for the subject or for the object dependencies, and it is shown that this causal equivalence can be reconducted to, or implemented into, the ordinary interleaving observation equivalence.
Abstract: We examine the meaning of causality in calculi for mobile processes like the $\pi$ -calculus, and we investigate the relationship between interleaving and causal semantics for such calculi. We separate two forms of causal dependencies on actions of $\pi$ -calculus processes, called subject and object dependencies: The former originate from the nesting of prefixes and are propagated through interactions among processes (they are the only form of causal dependencies present in CCS-like languages); the latter originate from the binding mechanisms on names. We propose a notion of causal bisimulation which distinguishes processes which differ for the subject or for the object dependencies. We show that this causal equivalence can be reconducted to, or implemented into, the ordinary interleaving observation equivalence. We prove that our encoding is fully abstract w.r.t. the two behavioural equivalences. This allows us to exploit the simpler theory of the interleaving semantics to reason about the causal one. In [San94b] a similar programme is carried out for location bisimulation [BCHK91], a non-interleaving spatial-sensitive (as opposed to causal-sensitive) behavioural equivalence. The comparison between the encodings of causal bisimulation in this paper, and of location bisimulation in [San94b], evidences the similarities and the differences between these two equivalences.

75 citations


Journal ArticleDOI
TL;DR: The compositional semantics of $B(PN)^2$– a simple, expressive concurrent programming language – is given, and an associated low-level net semantics is described, and the coherence of these high-level and low- level semantics is proved.
Abstract: This paper describes a high-level Petri net model called M-nets (for modular multilabelled nets). A distinctive feature of this model is that it allows both: unfolding, as do most other high-level net models; and composition – in particular, synchronisation – in a process algebraic style, turning the set of M-nets into an algebraic domain. It turns out that the composition operations of this domain have various algebraic properties. Moreover, the model is such that composition operations are coherent with unfolding, in the sense that the unfolding of a composite high-level net is the composition of the unfoldings of its components. One of the motivations for M-nets is that they be a vehicle for giving semantics of concurrent programming languages. To illustrate their capability for that, the compositional semantics of $B(PN)^2$ – a simple, expressive concurrent programming language – is given. An associated low-level net semantics is described, and the coherence of these high-level and low-level semantics is proved.

68 citations


Journal ArticleDOI
TL;DR: Several functions are proved to be time-computable and properties of one-way (space-bounded) cellular automata (OCA) are given.
Abstract: The capability of one-way (space-bounded) cellular automata (OCA) to time-compute functions is investigated. That means given a constant input of length \(n\) a distinguished cell has to enter a distinguished state exactly after \(f(n)\) time steps. The family of such functions (\({\cal C}\)(OCA)) is characterized in terms of formal language recognition. Several functions are proved to be time-computable and properties of \({\cal C}\)(OCA) are given. The time-computation at some points is concerned with the concept of signals and their realization which is quite formally defined for the first time.

46 citations


Journal ArticleDOI
TL;DR: Context-free grammars and pushdown automata over infinite alphabets are introduced and it is shown that a language is generated by a context-free grammar over an infinite alphabet if and only if it is accepted by a push down automaton over an Infinite alphabet.
Abstract: In this paper we introduce context-free grammars and pushdown automata over infinite alphabets. It is shown that a language is generated by a context-free grammar over an infinite alphabet if and only if it is accepted by a pushdown automaton over an infinite alphabet. Also the generated (accepted) languages possess many of the properties of the ordinary context-free languages: decidability, closure properties, etc.. This provides a substantial evidence for considering context-free grammars and pushdown automata over infinite alphabets as a natural extension of the classical ones.

45 citations


Journal ArticleDOI
TL;DR: An “efficient” algorithm for computing the number of iterations (recursive calls) of the Collatz function is given and a class of natural numbers for which the conjecture is true is described.
Abstract: This paper refers to the Collatz conjecture The origin and the formalization of the Collatz problem are presented in the first section, named “Introduction” In the second section, entitled “Properties of the Collatz function”, we treat mainly the bijectivity of the Collatz function Using the obtained results, we construct a (set of) binary tree(s) which “simulate(s)”– in a way that will be specified – the computations of the values of the Collatz function In the third section, we give an “efficient” algorithm for computing the number of iterations (recursive calls) of the Collatz function A comparison between our algorithm and the standard one is also presented, the first being at least 225 “faster” (300 in medium) Finally, we describe a class of natural numbers for which the conjecture is true

37 citations


Journal ArticleDOI
TL;DR: An algorithm is given that, after preprocessing time, finds and deletes an increasing subsequence of size $k$ (if it exists) in time $O(n + k^2)$.
Abstract: In this paper we consider the problem of finding sets of long disjoint monotone subsequences of a sequence of \(n\) numbers. We give an algorithm that, after \(O(n \log n)\) preprocessing time, finds and deletes an increasing subsequence of size \(k\) (if it exists) in time \(O(n + k^2)\). Using this algorithm, it is possible to partition a sequence of \(n\) numbers into \(2 \lfloor \sqrt n \rfloor\) monotone subsequences in time \(O(n^{1.5})\). Our algorithm yields improvements for two applications: The first is constructing good splitters for a set of lines in the plane. Good splitters are useful for two dimensional simplex range searching. The second application is in VLSI, where we seek a partitioning of a given graph into subsets, commonly refered to as the pages of a book, where all the vertices can be placed on the spine of the book, and each subgraph is planar.

30 citations


Journal ArticleDOI
TL;DR: The central objective of this work is the investigation of proof rules which allow to establish the correctness of behavioural implementations in a modular (and stepwise) way and are practicable enough to induce proof obligations that can be discharged with existing theorem provers.
Abstract: We introduce a concept of behavioural implementation for algebraic specifications which is based on an indistinguishability relation (called behavioural equality). The central objective of this work is the investigation of proof rules which allow us to establish the correctness of behavioural implementations in a modular (and stepwise) way and, moreover, are practicable enough to induce proof obligations that can be discharged with existing theorem provers. Under certain conditions our proof technique can also be applied for proving the correctness of implementations based on an abstraction equivalence between algebras in the sense of Sannella and Tarlecki. The whole approach is presented in the framework of total algebras and first-order logic with equality.

28 citations


Journal ArticleDOI
TL;DR: The definition of the product operator is generalised to form what is called a fusion operator, which provides algebraic ways of composing program statements in the refinement calculus in order to model effects such as conjunction of specifications, simultaneous execution, and embedding of smaller programs into larger contexts.
Abstract: In the refinement calculus, program statements are modelled as predicate transformers. A product operator for predicate transformers was introduced by Martin [18] and Naumann [25] using category theoretic considerations. In this paper, we look more closely at the refinement-oriented properties of this operator and at its applications. We also generalise the definition of the product operator to form what we call a fusion operator. Together, the fusion and product operators provide us with algebraic ways of composing program statements in the refinement calculus in order to model effects such as conjunction of specifications, simultaneous execution, and embedding of smaller programs into larger contexts.

28 citations


Journal ArticleDOI
TL;DR: This work differs from others' in that the additional condition concerning fairness is expressed through termination of related iteration statements, and existing proof rules for termination are extended to verify fair action systems.
Abstract: An action system is a framework for describing parallel or distributed systems, for which the refinement calculus offers a formalisation of the stepwise development method. Fairness is an important notion in modelling parallel or distributed systems, and this paper investigates a calculus for refinement of fair action systems. Simulations, which are proof techniques for refinement, are extended to verify fair action systems. Our work differs from others' in that the additional condition concerning fairness is expressed through termination of related iteration statements. For this purpose, existing proof rules for termination are extended. In the tradition of the refinement calculus, our approach to fairness is based on techniques developed mainly for sequential programming.

Journal ArticleDOI
TL;DR: It is shown that all four properties of Parikh thin and Parikh slender languages are decidable for bounded semilinear languages but undecidable for DT0L languages.
Abstract: A language L is called thin if for almost all n there is at most one word of length n in L. A language L is called slender if there is a positive integer k such that for any n there are at most k words of length n in L. The notions of Parikh thin and Parikh slender languages are defined similarly by counting the words with the same Parikh vectors instead of the words of the same length. In this paper we discuss decision problems concerning these four properties. It is shown that all four properties are decidable for bounded semilinear languages but undecidable for DT0L languages. As a consequence all these problems are decidable for context-free languages.

Journal ArticleDOI
TL;DR: It is shown that many combinatorial algorithms which generate certain objects of a given size systematically, actually follow a simple pattern, when the objects are coded appropriately as words in a suitable ordered alphabet.
Abstract: We show that many combinatorial algorithms which generate certain objects of a given size systematically, actually follow a simple pattern, when the objects are coded appropriately as words in a suitable ordered alphabet. This observation implies a complete average-case analysis of a type of algorithm generating these words lexicographically. This analysis can be carried out even in cases where no information about the algorithm itself is available. We demonstrate our results by discussing various concrete applications, such as the generation of words in a given regular language, the generation of permutations, the generation of subsets of a given set, the generation of semi-Dyck words, the generation of Motzkin words, the generation of \(t\)–ary ordered trees according to Ruskey and Zaks, the generation of ordered trees with bounded height and the generation of various classes of 0–balanced ordered trees.

Journal ArticleDOI
TL;DR: It is shown that universal pointer equalities may be used to reduce the number of superfluous existential equalities, and that existentialequalities may been used to obtain more universal equalities.
Abstract: A formalism is presented for tracking assertions which hold universally, i.e., at the end of all the execution paths to a given program point, and assertions which hold existentially, i.e., at the end of some execution paths. In the formalism, the assertions which hold at a given execution path are uniformly defined by an entry environment which contains the assertions which hold when the execution of the program begins and an environment transformer for every program construct. The novel aspect of our formalism is that Horn clauses are used to specify the consistent environments and the meaning of program constructs. The best iterative algorithm (a notion defined by P. Cousot and R. Cousot) for tracking universal and existential assertions simultaneously is given. Conditions are presented under which the best iterative algorithm can be efficiently implemented. The formalism is applied to the pointer equality problem in Pascal. It is shown that universal pointer equalities may be used to reduce the number of superfluous existential equalities, and that existential equalities may be used to obtain more universal equalities. Recent empirical results indicate that tracking the combination of may and must equalities leads to substantial improvements in the result of the analysis. For programs without recursively defined records, the best iterative algorithm can be effectively implemented. These results apply to multiple levels of pointers and can be extended to handle possibly recursive procedures. However, for programs with recursively defined data types further approximations are necessary, e.g., by using a finite graph to model all the possible pointer equalities. For simplicity, this paper does not present an analysis algorithm for this case.

Journal ArticleDOI
TL;DR: This paper addresses the following question: “Given a set of local records, is it possible that these records belong to the same consistent global record?” and extends the result to a very general asynchronous computational model that encompasses shared memory systems and various message passing systems.
Abstract: A global record (i.e. a set of local records, one for each process of an asynchronous computation) abstracts what is usually called global state, global checkpoint or global snapshot in particular problems. Consistent global records are important in many applications. This paper addresses the following question: “Given a set of local records, is it possible that these records belong to the same consistent global record?”. This question has been answered by Netzer and Xu in the particular context of message passing systems. This paper extends their result to a very general asynchronous computational model that encompasses shared memory systems and various message passing systems (with reliable or unreliable and point-to-point or multicast or broadcast communications).

Journal ArticleDOI
TL;DR: It is argued that worst-case behaviour is unlikely to arise in applications which are amenable to machine learning, and bounds for worst case behaviour are adduced.
Abstract: The use of a so-called concept lattice for deriving concepts from a given set of entities and attributes is examined. A number of variations are discussed including constrained, unconstrained and augmented concept lattices. Bounds for worst case behaviour, as well as conditions under which worst-case behaviour arises, are adduced. It is argued that worst-case behaviour is unlikely to arise in applications which are amenable to machine learning. Pruning is also mentioned as a means of keeping the lattice down to a tractable size.

Journal ArticleDOI
TL;DR: The main properties of the resulting institution are studied and used in establishing a categorial, denotational semantics of several basic constructs of object specification, namely aggregation, interconnection, abstraction (interfacing) and monotonic specialization.
Abstract: From an arbitrary temporal logic institution we show how to set up the corresponding institution of objects. The main properties of the resulting institution are studied and used in establishing a categorial, denotational semantics of several basic constructs of object specification, namely aggregation (parallel composition), interconnection, abstraction (interfacing) and monotonic specialization. A duality is established between the category of theories and the category of objects, as a corollary of the Galois correspondence between these concrete categories. The special case of linear temporal logic is analysed in detail in order to show that categorial products do reflect interleaving and reducts may lead to internal non-determinism.

Journal ArticleDOI
TL;DR: It is demonstrated that if standard Mergesort is implemented using finger search trees instead of arrays it optimally adapts to a set of measures of presortedness not fulfilled by any other algorithm.
Abstract: We demonstrate that if standard Mergesort is implemented using finger search trees instead of arrays it optimally adapts to a set of measures of presortedness not fulfilled by any other algorithm.

Journal ArticleDOI
TL;DR: This method can be employed to implement semantic data models on top of currently available object oriented database systems and can be specified with the flexibility of a conceptual schema while the obtained implementation exploits the efficiency of an object-oriented database system.
Abstract: In this paper, formal relationships between classes of objects based on semantic data models (i.e. conceptual classes) and classes of objects based on object models (i.e system classes), are established. The proposed method starts from conceptual classes and generates system classes. This method can be employed to implement semantic data models on top of currently available object oriented database systems. As a consequence, the database applications can be specified with the flexibility of a conceptual schema while the obtained implementation exploits the efficiency of an object-oriented database system. Both the correctness and the completeness of our method are demonstrated and a discussion on its complexity is provided.

Journal ArticleDOI
TL;DR: The variety Lang has no finite axiomatization over the variety of ordered algebras ${\bf Lg}_\leq generated by the structures $(P_\Sigma,\cdot,\otimes,1,\subseteq)$, where $\sub seteq$ denotes set inclusion.
Abstract: We consider language structures ${\bf L}_\Sigma = (P_\Sigma,\cdot,\otimes,+,1,0)$ , where $P_\Sigma$ consists of all subsets of the free monoid $\Sigma^*$ ; the binary operations $\cdot$ , $\otimes$ and $+$ are concatenation, shuffle product and union, respectively, and where the constant 0 is the empty set and the constant 1 is the singleton set containing the empty word. We show that the variety Lang generated by the structures ${\bf L}_\Sigma$ has no finite axiomatization. In fact we establish a stronger result: The variety Lang has no finite axiomatization over the variety of ordered algebras ${\bf Lg}_\leq$ generated by the structures $(P_\Sigma,\cdot,\otimes,1,\subseteq)$ , where $\subseteq$ denotes set inclusion.

Journal ArticleDOI
TL;DR: It is shown in [Han94] that model checking for TPCTL has exponential time complexity, the latter being measured in terms of the size of formula, thesize of transition system and the value of explicit time that appears in the formula.
Abstract: We consider the model checking problem for Timed Probabilistic Computation Tree Logic (TPCTL) introduced by H.A. Hansson and D. Jonsson, and studied in a recent book by H.A. Hansson [Han94]. The semantics of TPCTL is defined in terms of probabilistic transition systems. It is shown in [Han94] that model checking for TPCTL has exponential time complexity, the latter being measured in terms of the size of formula, the size of transition system and the value of explicit time that appears in the formula. Besides that, [Han94] describes some polytime decidable classes, the proofs being rather voluminous. We show, by a short proof, that this model checking problem is polytime decidable in the general case. The proof is essentially based on results on the complexity of Markov decision processes.

Journal ArticleDOI
TL;DR: It is observed that every first-order logic formula over the untyped version of some many-sorted vocabulary is equivalent to a union of many-Sorted formulas over that vocabulary.
Abstract: We observe that every first-order logic formula over the untyped version of some many-sorted vocabulary is equivalent to a union of many-sorted formulas over that vocabulary. This result has as direct corollary a theorem by Hull and Su on the expressive power of active-domain quantification in the relational calculus.

Journal ArticleDOI
TL;DR: It is shown that the unsatisfactory presentation of DS predicate calculus and some of its features has led to errors and fallacies in the literature, and gives it a firm basis, on a par with the foundations of the well-known first order logic.
Abstract: The paper focusses on the logical backgrounds of the Dijkstra-Scholten program development style for correct programs. For proving the correctness of a program (i.e. the fact that the program satisfies its specifications), one often uses a special form of predicate calculus in this style of programming. We call this the Dijkstra-Scholten (DS) predicate calculus, since [DS90] is the first place in which it is described. DS predicate calculus can be conceived of as a logically sound and complete manipulation technique for dealing with logical formulas which also contain programming variables. We relate DS predicate calculus to the classical logical formalism, by contrasting its syntax, derivation rules and semantics to the classical framework. We also comment on two abstractions of DS predicate calculus: the set-theoretical and the algebraic approach. In doing so, we give DS predicate calculus and its abstract variants a firm basis, on a par with the foundations of the well-known first order logic. Such a comparison of DS predicate calculus and classical logic has not yet been sufficiently elaborated before. We conclude our paper with a number of examples showing that the, up to now, unsatisfactory presentation of DS predicate calculus and some of its features (such as the square brackets notation) has led to errors and fallacies in the literature.

Journal ArticleDOI
TL;DR: It is shown that there are infinitely many cyclic-square-free words over alphabet with three letters and it is proved that every regular component in D (1) is either a prefix code or a suffix code.
Abstract: Let X be a finite alphabet containing more than one letter. A d-primitive word u overX is a non-overlapping word in the sense that no proper prefix of u is a suffix of u. D(1) is the set of all d-primitive words over X and D is the set of all positive powers of all words in D (1). Every language in D will be called a d-language. In this paper, we study some algebraic properties of d-primitive words and d-languages relative to formal language theory and codes. We show that there are infinitely many cyclic-square-free words over alphabet with three letters. A characterization of three elements codes in D (1) is obtained and we prove that every regular component in D (1) is either a prefix code or a suffix code.

Journal ArticleDOI
TL;DR: The reachability problem for such Petri nets to be NP-complete and the boundedness problem, an NP-completeness result is demonstrated for priority conflict-free Petrinets with two types of prioritized transitions.
Abstract: A number of problems concerning priority conflict-free Petri nets are investigated in this paper. We show the reachability problem for such Petri nets to be NP-complete. (Using a similar technique, the NP-completeness result applies to the class of priority BPP-nets as well.) As for the boundedness problem, an NP-completeness result is demonstrated for priority conflict-free Petri nets with two types of prioritized transitions. (In contrast, the problem is known to be P-complete for conflict-free Petri nets without priorities.) We also investigate the home state problem, i.e., the problem of determining whether home states exist in a given a Petri net, for conflict-free Petri nets with and without priorities. As it turns out, home states always exist for bounded conflict-free Petri nets without priorities. If an additional liveness constraint is imposed, such Petri nets are guaranteed to be ‘reversible’ (i.e., their initial states are home states). For priority conflict-free Petri nets, being bounded and live is sufficient for the existence of home states. However, if the liveness assumption is dropped, the existence of home states is no longer guaranteed.

Journal ArticleDOI
TL;DR: A classification for a set of linearly recursive functions, which can be expressed as instances of a skeleton for parallel linear recursion, and present new parallel implementations for them.
Abstract: We propose a classification for a set of linearly recursive functions, which can be expressed as instances of a skeleton for parallel linear recursion, and present new parallel implementations for them. This set includes well known higher-order functions, like Broadcast, Reduction and Scan, which we call basic components. Many compositions of these basic components are also linearly recursive functions; we present transformation rules from compositions of up to three basic components to instances of our skeleton. The advantage of this approach is that these instances have better parallel implementations than the compositions of the individual implementations of the corresponding basic components.

Journal ArticleDOI
Hsien-Kuei Hwang1
TL;DR: In this paper, the mean and variance of the cost of top-down recursive mergesort were investigated. But they did not provide exact formulae for the mean or variance.
Abstract: This note provides exact formulae for the mean and variance of the cost of top-down recursive mergesort. These formulae improve upon earlier results of Flajolet and Golin.

Journal Article
TL;DR: In this article, a hierarchy of operations on (finite and infinite) binary trees is introduced, which are obtained by successive repetition of one initial operation, and are generalizations of the operations of addition, multiplication and exponentiation for positive integers.
Abstract: We introduce a hierarchy of operations on (finite and infinite) binary trees. The operations are obtained by successive repetition of one initial operation. The first three operations are generalizations of the operations of addition, multiplication and exponentiation for positive integers.

Journal ArticleDOI
TL;DR: The transformational approach can be seen as unifying in a common framework a set of different techniques of program analysis, which is based only on syntactic transformations, thus it does not requires any semantic information.
Abstract: Program transformation techniques have been extensively studied in the framework of functional and logic languages, where they were applied mainly to obtain more efficient and readable programs. All these works are based on the Unfold/Fold program transformation method developed by Burstall and Darlington in the context of their recursive equational language. The use of Unfold/Fold based transformations for concurrent languages is a relevant issue that has not yet received an adequate attention. In this paper we define a transformation methodology for CCS. We give a set of general rules which are a specialization of classical program transformation rules, such as Fold and Unfold. Moreover, we define the general form of other rules, “oriented” to the goal of a transformation strategy, and we give conditions for the correctness of these rules. We prove that a strategy using the general rules and a set of goal oriented rules is sound, i.e. it transforms CCS programs into equivalent ones. We show an example of application of our method. We define a strategy to transform, if possible, a full CCS program into an equivalent program whose semantics is a finite transition system. We show that, by means of our methodology, we are able to a find finite representations for a class of CCS programs which is larger than the ones handled by the other existing methods. Our transformational approach can be seen as unifying in a common framework a set of different techniques of program analysis. A further advantage of our approach is that it is based only on syntactic transformations, thus it does not requires any semantic information.

Journal ArticleDOI
TL;DR: Using predicate transformers as a basis, semantics and refinement rules for mixed specifications that allow UNITY style specifications to be written as a combination of abstract program and temporal properties are given.
Abstract: Using predicate transformers as a basis, we give semantics and refinement rules for mixed specifications that allow UNITY style specifications to be written as a combination of abstract program and temporal properties. From the point of view of the programmer, mixed specifications may be considered a generalization of the UNITY specification notation to allow safety properties to be specified by abstract programs in addition to temporal properties. Alternatively, mixed specifications may be viewed as a generalization of the UNITY programming notation to allow arbitrary safety and progress properties in a generalized ‘always section’. The UNITY substitution axiom is handled in a novel way by replacing it with a refinement rule. The predicate transformers foundation allows known techniques for algorithmic and data-refinement for weakest precondition based programming to be applied to both safety and progress properties. In this paper, we define the predicate transformer based specifications, specialize the refinement techniques to them, demonstrate soundness, and illustrate the approach with a substantial example.