Recognition Of Context-free Languages Research Articles

Recognition of poly-slender context-free languages by trellis automata

A poly-slender context-free language is a context-free language whose number of words of length n is polynomially bounded. Its structure has been thoroughly characterized by Ilie, Rozenberg and Salomaa. Thanks to this characterization, we show that every poly-slender context-free language is recognizable by a trellis automaton, if the languages of words with as many a as b and at most a constant number of alternations between a and b are recognizable by trellis automata. Then we construct a family of trellis automata that recognizes such languages.

Simulation of Two-Way Pushdown Automata Revisited

The linear-time simulation of 2-way deterministic pushdown automata (2DPDA) by the Cook and Jones constructions is revisited. Following the semantics-based approach by Jones, an interpreter is given which, when extended with random-access memory, performs a linear-time simulation of 2DPDA. The recursive interpreter works without the dump list of the original constructions, which makes Cook's insight into linear-time simulation of exponential-time automata more intuitive and the complexity argument clearer. The simulation is then extended to 2-way nondeterministic pushdown automata (2NPDA) to provide for a cubic-time recognition of context-free languages. The time required to run the final construction depends on the degree of nondeterminism. The key mechanism that enables the polynomial-time simulations is the sharing of computations by memoization.

On the recognition of context-free languages using accepting hybrid networks of evolutionary processors

In this paper we approach the problem of constructing an accepting device for the class of context-free languages, based on a newly defined computational model: Accepting Hybrid Network of Evolutionary Processors (AHNEPs). Although it is known that AHNEPs are Turing complete, and, consequently, for every context-free language, seen as a recursively enumerable language, we can construct an AHNEP that simulates the Turing machine accepting it, we choose a direct approach: the AHNEPs we design simulate the computation done by a non-deterministic push-down automata accepting the language. This approach leads to a more economic AHNEP since the number of processors we use depends linearly on the number of states and the number of working symbols of the automaton, while for the network obtained in the general case of recursively enumerable languages, the number of processors is linear in the number of states, but quadratic in the number of working symbols of a Turing machine accepting the given language. Finally, we particularize the AHNEP architecture we proposed in order to recognize regular languages. We obtain an upper bound for the number of processors needed close to that known for generating hybrid networks of evolutionary processors.

Cache efficient simple dynamic programming

New cache-oblivious and cache-aware algorithms for simple dynamic programming based on Valiant's context-free language recognition algorithm are designed, implemented, analyzed, and empirically evaluated with timing studies and cache simulations. The studies show that for large inputs the cache-oblivious and cache-aware dynamic programming algorithms are significantly faster than the standard dynamic programming algorithm.

Parallel RAMs with owned global memory and deterministic context-free language recognition

We identify and study a natural and frequently occurring subclass of Concurrent Read, Exclusive Write Parallel Random Access Machines (CREW-PRAMs). Called Concurrent Read, Owner Write, or CROW-PRAMS, these are machines in which each global memory location is assigned a unique “owner” processor, which is the only processor allowed to write into it. Considering the difficulties that would be involved in physically realizinga full CREW-PRAM model and demonstrate its stability under several definitional changes. Second, we precisely characterize the power of the CROW-PRAM by showing that the class of languages recognizable by it in time O (log n) (and implicity with a polynomial number of processors) is exactly the class LOGDCFL of languages log space reducible to deterministic context-free languages. Third, using the same basic machinery, we show that the recognition problem for deterministic context-free languages can be solved quickly on a deterministic auxilliary pushdown automation having random access to its input tape, a log n space work tape, and pushdown store of small maximum height. For example, time O ( n 1 + ε ) is achievable with pushdown height O (log 2 n ). These result extend and unify work of von Braunmöhl, Cook, Mehlhorn, and Verbeek, Klein and Reif; and Rytter.

Approximation and exact algorithms for RNA secondary structure prediction and recognition of stochastic context-free languages

For a basic version (i.e., maximizing the number of base-pairs) of the RNA secondary structure prediction problem and the construction of a parse tree for a stochastic context-free language, O(n 3 ) time algorithms were known. For both problems, this paper shows slightly improved O(n 3 (log logn) 1/2 /(log n) 1/2 ) time exact algorithms, which are obtained by combining Valiant's algorithm for context-free recognition with fast funny matrix multiplication. Moreover, this paper shows an O(n 2.776 + (1/∈) O(1) ) time approximation algorithm for the former problem and an O(n 2.976 log n + (1/∈) O(1) ) time approximation algorithm for the latter problem, each of which has a guaranteed approximation ratio I - ∈ for any positive constant ∈, where the absolute value of the logarithm of the probability is considered as an objective value in the latter problem. The former algonthm is obtained from a non-trivial modification of the well-known O(n 3 ) time dynamic programming algorithm, and the latter algorithm is obtained by combining Valiant's algorithm with approximate funny matrix multiplication. Several related results are shown too.

An innovative finite state concept for recognition and parsing of context-free languages

In the full paper in the companion volume, we introduce a new subclass of the context free languages, the meta-deterministic languages, which includes the deterministic languages, but also the languages that result if deterministic languages are combined via regular expressions.

Pointers versus Arithmetic in PRAMs

Manipulation of pointers in shared data structures is an important communication mechanism used in many parallel algorithms. Indeed, many fundamental algorithms do essentially nothing else. Aparallel pointer machine(or PPM) is a parallel model having pointers as its principal data type. PPMs have been characterized as PRAMs obeying two restrictions—first, restricted arithmetic capabilities and, second, the CROW memory access restriction (concurrent read, owner write, a commonly occurring special case of CREW). We present results concerning the relative power of PPMs (and other arithmetically restricted PRAMs) versus CROW PRAMs having ordinary arithmetic capabilities. First, we prove lower bounds separating PPMs from CROW PRAMs. For example, any step-by-step simulation of ann-processor CROW PRAM by a PPM requires timeΩ(loglogn) per step. Second, we show that this lower bound is tight— we give such a step-by-step simulation using O(loglogn) time per step. As a corollary, we obtain sharply improved PPM algorithms for a variety of problems, including deterministic context-free language recognition.

The Sublogarithmic Alternating Space World

This paper tries to fully characterize the properties and relationships of space classes defined by Turing machines (TMs) that use less than logarithmic space—be they deterministic, nondeterministic, or alternating (DTMs, NTMs, or ATMs). We provide several examples of specific languages and show that such machines are unable to accept these languages. The basic proof method is a nontrivial extension of the $1^n \mapsto 1^{n + n!} $ technique to alternating TMs. Let 1log denote the logarithmic function log iterated twice, and let $\Sigma _k {\textit{Space}}(S) $ and $\prod _k {\textit{Space}}(S)$ be the complexity classes defined by S-space-bounded ATMs that alternate at most $k - 1$ times and start in an existential (resp., universal) state. Our first result shows that for each $k > 1$, the sets \[ \begin{gathered} \hfill \Sigma _k {\textit{Space}}(1\log )\backslash \Pi _k Space(o(\log )) \quad {\text{and}} \\ \hfill \Pi _k {\textit{Space}}(1\log )\backslash \Sigma _k {\textit{Space}}(o(\log )) \\ \end{gathered} \] are both not empty. This implies that for each $S \in \Omega (1\log ) \cap o(\log )$, the classes \[ \begin{gathered} \Sigma _1 {\textit{Space}}(S) \subset \Sigma _2 {\textit{Space}}(S) \subset \Sigma _3 {\textit{Space}}(S) \subset \cdots \\ \subset \sum\nolimits_k {Space(S) \subset } \sum\nolimits_{k + 1} {Space(S) \subset } \cdots \\ \end{gathered} \] form an infinite hierarchy. Furthermore, this separation is extended to space classes defined by ATMs with a nonconstant alternation bound A provided that the product $A \cdot S$ grows sublogarithmically. These lower bounds can also be used to show that basic closure properties do not hold for such classes. We obtain that for any $S \in \Omega (1\log ) \cap o(\log )$ and all $k > 1$, $\Sigma _k {Space(S)} $ and $\prod _k {\textit{Space}}(S)$ are not closed under complementation and concatenation. Moreover, $\Sigma _k {{\textit{Space}}(S)} $ is not closed under intersection and $\prod _k {\textit{Space}}(S)$ is not closed under union. It is also shown that ATMs recognizing bounded languages can always be guaranteed to halt. For the class of Z-bounded languages with $Z \leqslant \exp S$, we obtain the equality co-$\Sigma _k {{\textit{Space}}(S)} = \Pi _k {\textit{Space}}(S)$. Finally, for sublogarithmic bounded ATMs, we give a separation between the weak and strong space measure and prove a logarithmic lower space bound for the recognition of nonregular context-free languages.

Efficient parallel recognition of context-free languages

This paper presents an efficient parallel approach for recognition of context-free languages. The algorithm takes O(log n) time of computations on a fixed configuration of processors array with reconfigurable bus system. The number of processors required is O( n 3). Processor architecture consists of multibus and multiple internal switches in the processors. A specific arrangement of processors is required. Achievements in terms of time and processors requirement have been further supplemented with the elimination of dependence of processor complexity on the size of grammar.

Parallel recognition and parsing on mesh connected computers with multiple broadcasting

In this paper we present an optimal linear time algorithm for recognition and parsing of context-free languages on n × n mesh connected computers with multiple broadcasting, for an input string of length n. Our algorithm is based on the well-known Cocke-Younger-Kasami (CYK) algorithm for the recognition and parsing of context-free languages, and is faster than two recent algorithms available in the literature. The parallel recognition of context-free languages is of particular importance since parallel compilation is an increasingly important application because of the availability of parallel hardware and the long running times of optimizing and parallelizing compilers. Our algorithm is a contribution towards this end.

Ann 2 algorithm for recognition of context-free languages

Ann 2 algorithm for recognition of context-free languages

A bibliography on parallel parsing

This bibliography on parallel parsing and recognition of context-free languages covers most of the important publications in this area of computer science and natural language processing. The list of publications is preluded by an introduction which presents an overview of the field.

Observations on log ( n) time parallel recognition of unambiguous cfl's

We present two simpler versions of the log( n) time parallel recognition of unambiguous context-free languages on CREW PRAM's. The first algorithm combines the ideas of the algorithms given in [3] and [7]. The result related to that algorithm is an unambiguous decomposition of trees into smaller ones. The analysis of this algorithm is quite simple. The second algorithm is based on unique paths decomposing trees into smaller subtrees. It has a shorter description and it is simpler to explain how it works. However, its correctness is nontrivial. Both algorithms reduce the numbers of processors by a linear factor in the case of general unambiguous cfl's. For linear unambiguous cfl's the number of processors is reduced to O( n 2) by a very simple algorithm. We show how to remove write conflicts in parallel computations on trees by using two kinds of unique decompositions of trees. Finally we show that our results can be generalized for finitely ambiguous cfl's.

Two dynamic programming algorithms for which interpreted pebbling helps

We consider extensions of one-person and two-person pebble games that take into account the types of the gates of the circuits on which the games are played. A simple relationship is established between the extended games and the corresponding original games. This is useful in showing that the extended games allow more efficient pebbling than the original games on certain natural circuits for problems such as context-free language recognition and transitive closure of directed graphs.

On the complexity of the recognition of parallel 2D-image languages

We investigate the complexity of images generated by a class of parallel context-free image grammars. We show that the sequential time complexity of the recognition of n × n images generated by parallel context-free grammars is O( M( n)), where M( n) is the time to multiply two boolean n × n matrices. Using a parallel random access machine the recognition can be done in O(log 2( n)) time with n 6 processors. Hence the complexity is essentially the same as the complexity of the recognition of ordinary context-free languages.

On the parallel recognition of unambiguous context-free languages

We present a simple parallel algorithm recognizing unambiguous context-free languages on a CREW PRAM in time log 2 n with only n 3 processors. This gives the smallest number of processors known for the recognition of unambiguous context-free languages in polylogarithmic time. Using the same framework a new algorithm is also given for the recognition of deterministic context-free languages in log 2 n time with quadratic number of processors.

On mapping systolic algorithms onto the hypercube

Consideration is given to the problem of mapping systolic array algorithms into efficient algorithms for a fixed-size hypercube architecture. The authors describe in detail several optimal implementations of algorithms given for one-way one- and two-dimensional systolic arrays. Since interprocessor communication is many times slower than local computation in parallel computers built to date, the problem of efficient communication is specifically addressed for these mappings. In order to validate the technique experimentally, five systolic algorithms were mapped in various ways onto a 64-node NCUBE/7 MIMD hypercube machine. The algorithms are for the following problems: the shuffle scheduling problem, finite impulse response filtering, linear context-free language recognition, matrix multiplication, and computing the Boolean transitive closure. Experimental evidence indicates that good performance is obtained for the mappings. >

On efficient parallel computations for some dynamic programming problems

A general method for parallelization of some dynamic programming algorithms on VLSI was presented in [6]. We present a general method for parallelization for the same class of problems on more powerful parallel computers. The method is demonstrated on three typical dynamic programming problems: computing the optimal order of matrix multiplications, the optimal binary search tree and optimal triangulation of polygons (see[1,2]). For these problems the dynamic programming approach gives algorithms having a similar structure. They can be viewed as straight-line programs of size O( n 3). The general method of parallelization of such programs described by Valiant et al. [16] then leads directly to algorithms working in log 2 n time with O( n 9) processors. However we adopt an alternative approach and show that a special feature of dynamic programming problems can be used. They can be thought as generalized parsing problems: find a tree of the optimal decomposition of the problem into smaller subproblems. A parallel pebble game on trees [10,11] is used to decrease the number of processors and to simplify the structure of the algorithms. We show that the dynamic programming problems considered can be computed in log 2 n time using n 6 log n processors on a parallel random-access machine without write conflicts (CREW P-RAM). The main operation is essentially matrix multiplication, which is easily implementable on parallel computers with a fixed interconnection network of processors (ultracomputers, in the sense of [15]). Hence the problems considered can also be computed in log 2 n time using n 6 processors on a perfect shuffle computer (PSC) or a cube- connected computer (CCC). An extension of the algorithm from [14] for the recognition of context-free languages on PSC and CCC can be used. If the parallel random access machine with concurrent writes (CRCW P-RAM) is used, then the minimum of mnumbers can be determined in constant time (see [8]) and consequently the parallel time for the computation of dynamic programming problems can be reduced from log 2 n to log n. We investigate also the parallel computation of trees realizing the optimal cost of dynamic programming problems.

Parallel time O(log n) recognition of unambiguous context-free languages

We prove that every unambiguous context-free language can be recognized in O (log n ) time on a parallel random access machine without write conflicts (P-RAM) using a polynomial number of processors. This strengthens the result of Reif (1982 , in “Proceedings, 23rd IEEE Symp. Found. Comput.,” pp. 114–118), who proved that every deterministic context-free language can be recognized on a P-RAM in O (log n ) time.