Ernst L. Leiss

Succinct representation of regular languages by boolean automata II

Abstract Boolean automata are a generalization of finite automata in the sense that the next state (the result of the transition function, given a state and a letter) is not just a single state (deterministic automata) or a set of states (nondeterministic automata) but a boolean function of the states. Boolean automata accept precisely the regular languages; also, they correspond in a natural way to certain language equation involving complementation as well as to sequential networks. In a previous note we showed that for every n ⩾ 1, there exists a boolean automaton B n with n states such that the smallest deterministic automaton for the same language has 2 2 n states. In the present note we will show a precisely attainable lower bound on the succinctness of representing regular languages by boolean automata; namely, we will show that, for every n ⩾ 1, there exists a reduced automaton D n with n states such that the smallest boolean automaton accepting the same language has also n states.

Unrestricted complementation in language equations over a one-letter alphabet

Recently, the complete solution of systems of language equations over a one-letter alphabet has been derived where the operators are union, concatenation and star. This paper addresses the question of adding the complementation operator. It is known that if no stars are present and if the concatenation operator is restricted, such equations need not have solutions, but if they do, they can be solved explicitly if the constants are regular in which case the solutions are also regular. In this paper we study language equations over a one-letter alphabet where unrestricted concatenation interacts with complementation, union, and star. We define a procedure for determining a regular solution of the general type of equation assuming that all constants are regular, discuss its properties, and show examples. We then prove that in general equations with complementation and complementation and concatenation in which all constants are regular may have nonregular solutions. This shows that language equations can be used to obtain non-context-free languages from regular languages using only operators under which the regular languages are closed.

Modulo scheduling for the TMS320C6x VLIW DSP architecture

Digital Signal Processing (DSP) architectures are specialized for high performance numerical algorithms such as those found in communication and multimedia applications. The development of efficient compilers for DSP processors is a growing research area. The Texas Instruments TMS320C6x (C6x) is a Very Long Instruction Word (VLIW) DSP architecture capable of issuing eight operations in parallel. In this paper, we present the results of implementing a software pipelining algorithm for the C6x. We provide a description of the C6x and detail the architectural features that impact software pipelining such as a moderately sized register file, constraints on code size, homogeneous resources, and multiple assignment code. We discuss how we adapted modulo scheduling to implement software pipelining for the C6x. Finally, we present the results of modulo scheduling a set of 40 loop kernel benchmarks and measure the algorithm in terms of schedule quality and algorithm complexity.

On generalized language equations

A system of generalized language equations over an alphabet A is a set of n equations in n variables: Xi = Gi(X1,..., Xn), i = 1,...,n, where the Gi are functions from [P(A*)]n into P(A*), i=1,..., n, P(A*) denoting the set of all languages over A. Furthermore the Gi are expressible in terms of set-operations, concatenations, and stars which involve the variable Xi as well as certain mixed languages. In this note we investigate existence and uniqueness of solutions of a certain subclass of generalized language equations. Furthermore we show that a solution is regular if all fixed languages are regular.

The effect of statically and dynamically replicated components on system reliability

The reliability of general systems using dynamic and static redundancy schemes is derived, and communication protocols are considered as a representative example. The system reliability for three broadcast protocols using various redundancy-allocation policies is studied. The analytic and simulation results show that, in some cases, static redundancy yields a more reliable system than dynamic redundancy. This is essential for distributed system applications. In some cases, the failure detection time is substantial, so that the hardware reliability and hence the system reliability are adversely affected when using dynamic redundancy. This can be a critical factor for distributed system applications, because a large overhead of communication can be required for error detection. In these cases, unreliable protocols can provide better system reliability than reliable protocols, especially when the communication network is highly reliable and when the machine failure rate is relatively large. Since unreliable protocols generate less load and less resource contention, they are preferable in such cases. The reliability should be analyzed to determine the optimal balance between reliable and unreliable protocols. Static redundancy can be more reliable than dynamic redundancy if the failure-detection time is large. >

Division and sign detection algorithms for residue number systems

Abstract This paper is concerned with the operations of division and sign detection in residue number systems. CORDIC, a well-known iterative algorithm originally designed for conventional floating point representation, is adapted for residue division. Since sign detection is required by the division algorithm we have also considered this problem. A modified sign detection algorithm which yields a high degree of parallelism is introduced resulting in time efficient division and sign detection.

The complexity of restricted regular expressions and the synthesis problem for finite automata

Abstract It is known that for every restricted regular expression of length n there exists a nondeterministic finite automaton with n + 1 states giving rise to the upper bound of 2 n + 1 on the number of states of the corresponding reduced automaton. In this note we show that this bound can be attained for all n ⩾ 2, i.e., the upper bound 2 n + 1 is optimal. An observation is then made about the synthesis problem for nondeterministic finite automata.

Constructing a finite automaton for a given regular expression

Regular expressions have a number of applications in computer science; the most important one is probably the lexical analysis of programs (see for instance [3]). Other applications are pattern recognition and pattern matching (including text editing and bibliographical search systems). Common to all these approaches is that the regular expression must be converted into a finite automaton; in most cases it is to be a deterministic automaton. This is usually achieved by first constructing a nondeterministic automaton accepting the language denoted by the expression and then applying the subset construction to it, possibly reducing the resulting deterministic automaton afterwards. A closer look at the algorithms involved in this process reveals that as far as its computational complexity is concerned the most crucial step is the construction of the nondeterminJstic automaton. For if we can construct a nondetermJnlstic automaton with n states corresponding to a given regular expression, then the equivalent deterministic automaton may have up to 2 n states and since reducing of an m-state deterministic automaton Js of time complexity O(m log m) the complete process may therefore be of time complexity O(n 2n). However, suppose that in the first step we obtain a nondeterminlstic automaton with 2n states :for the same expression, then the

An inherently fault tolerant sorting algorithm

The paper defines inherent fault tolerance and illustrates this approach by developing an inherently fault tolerant parallel sorting algorithm. In particular, it shows, how the algorithm can be developed systematically in four steps, namely, by starting with a conventional algorithm, extending it to an infinite iterative algorithm, incorporating inherent fault tolerance, and improving the performance. This inherently fault tolerant sorting algorithm sorts the input sequence of size N using N/2 processors in O(log/sup 2/N) time if there is no processor failure and sorts in O(2/sup (log(f+1))/log/sup 2/N), time if f processors have failed.<<ETX>>

Embedding complete binary trees into hypercubes

The object is to embed complete binary trees into hypercubes such that every edge in the tree is mapped to an edge in the hypercube.