Tilburg University
Recognition for acyclic context-sensitive grammars is probably polynomial for fixed
grammars
Aarts, E.
Publication date:
1991
Document Version
Publisher's PDF, also known as Version of record Link to publication in Tilburg University Research Portal
Citation for published version (APA):
Aarts, E. (1991). Recognition for acyclic context-sensitive grammars is probably polynomial for fixed grammars. (ITK Research Memo). Institute for Language Technology and Artifical IntelIigence, Tilburg University.
General rights
Copyright and moral rights for the publications made accessible in the public portal are retained by the authors and/or other copyright owners and it is a condition of accessing publications that users recognise and abide by the legal requirements associated with these rights. • Users may download and print one copy of any publication from the public portal for the purpose of private study or research. • You may not further distribute the material or use it for any profit-making activity or commercial gain
• You may freely distribute the URL identifying the publication in the public portal
Take down policy
:BM ~~ ~ , ~ CRM ~~~~~5 ~ ~~ ~~~. 8419 -J`` ~~`~`.~~,~~ 1991 J~~ ~~~ 8
hNMllIINIIIIIIIIIINIIIIIIIIINh~nIIIIInl
i; r',:. ~, -;E. - K ~ ~rr~ t' 4~ ~~ -E
Í-!!.~:~:~- ti.
I.T.K. Research Memo
June 1991
Recognition for Acyclic
Context-Sensitive Grammars
is probably Polynomial for
Fixed Grammars
Erik Aarts
no. 801991. Institute for Language Technology and Artificial Intelligence,
Tilburg University, P.O.Box 90153, 5000 LE Tilburg, The Netherlands
Recognition for Acyclic Context-Sensitive Grammars is Probably
Polynomial for Fixed Grammars
Erik Aarts
Institute for Language Technology and Artificial Intelligence PoBox 90153
5000 LE Tilburg The Netherlands
Abstract
Contezt-sensitive grammars in which each rule is of the formaZQ ~ aryj.i are acyclic if the associated contezt-free grammar with the rules Z~ ry is acyclic. The problem whether an inputstring is in the language generated by an acyclic contezt-sensitive grammar is probably polynomial for fized grammars.
Introduction
One of the most well-known classifications of rewrite grammars is the Chomsky hierarchy. Gram-mars and languages are of type 0(unrestricted), type 1(context-sensitive), type 2(context-free) or of type 3(regular). Much research has been done involving regular and context-free grammazs. Context-free languages can be recognized in a time that is polynomial in the length of the input and the length of the grammar (Eazley, 1970]. Recognition of type 0 languages is undecidable. We see two majors tracks for the research on grammars which lie between these two very distant complexity classes.
First, people have tried to put restrictions on context-sensitive grammars in order to generate context-free languages. Among them are Book [1972], Hibbard [1974] and Ginsburg and Greibach [1966]. Baker [1974] has shown that these attacks come down to the same more or less. They all block the use of context to pass information through the string. Book [1973] gives an overview of attempts to generate context-free languages with non-context-free grammars. How to restrict permutative grammazs in order to generate context-free languages is described in Mákkinen (1985]. The other track is the track of complexity of recognition. One of the best introductions to complexity theory is Gazey and Johnson [1979]. They state that recognition for context-sensitive grammazs is PSPACE-complete (referring to [Kuroda, 1964] and [Kazp, 1972]). Some people have tried to put restrictions on CSG's so that recognition lies somewhere between PSPACE and P. Book [1978] has shown that for linear time CSG's recognition is NP-complete even for (some) fixed grammars. Furthermore there is a result that recognition for growing CSG's is polynomial for fixed grammars [Dahlhaus and Warmuth, 1986]. This is the tradition I am following.
In this article I will consider one type of restricted context-sensitive grammars, the acyclic context sensitive grammazs. The complexity of recognition is lower than in the unrestricted case because we restrict the amount ofinformation that can be sent (and we do not block it by barriers!). In the unrestricted case we can send messages that leave no irace. After a message that changes 0's into 1's e.g. we can send a message that does the reverse. In sending a message from one position in the sentence to another, the intermediate symbols are not changed. In fact they are changed twice: back and forth. With acyclic csg's, this is not possible and the amount of information that
Definitions
A grammar is a 4-tuple, G-(V, E, R, S), where
V is a set of symbols, E C V is the set of terminal symbols.
R C V' x V' is a relation defined on strings. Elements of R aze called rules. S E V is the staztsymbol.
A grammaz is context-aenaitive if each rule is of the form
aZA--~arypwhereZEV`E;a,p,ryEV';1'~e.
A grammaz is context- f ree if each rule is of the form
Z~rywhere ZEV`E;ryEV' ;ry~e.
Derivability (~) between strings is defined as follows:
uav ~ u,Qv (u, v, a, ~B E V' ) ifï (a, (i) E R.
The transitive closure of ~ is denoted by ~. The transitive reflexive closure of ~ is denoted by
~. The language generated by G is defined as L(G) -{w E E' ~ S~ w}.
A derivation of a string b is a sequence of strings xl, xz, ... , x„ with
S-xl,foralli(1CiGn)x;~x;tl andx„-b.
A context-free grammar is acyclic if there is no Z E V`E such that
Z~ Z. This implies that there is no string a E V' such that a~ a.
We can map a context-sensitive grammaz G onto its associated context-free grammaz G' as follows:
If G is (V, E, R, S) then G' is (V, E, R', S) where for every rule aZp -~ a7~i E R there is a rule
Z~ ry E R~. There aze no other rules in R'.
We call G acyclic iff the associated context-free grammaz G' is acyclic. The notation we use for context-sensitive rules is as follows: the rule
aZ,Q -~ aryA is written as Z --~ (al][az] . . . [a;] ry [Al][Az] . . . [(~~] with
a - [ai][az] . . . [a,J and Q - [Ai][Qz] . . . [Q~].
Recognition is polynomial
In this section we try to prove that the recognition problem for acyclic context-sensitive grammars is polynomial. Acyclic CSG will be abbreviated as ACSG. Suppose we have an acyclic
context-sensitive grammaz G- (V, E, R, S).
RECOGNITION FOR A FIXED ACYCLIC CSG INSTANCE: a string w E E'.
QUESTION: Is w in the language generated by G?
We try to prove that RECOGNITION FOR A FIXED ACYCLIC CSG is polynomial for every ACSG. We shall give an algorithm that recognizes sentences of some ACSG. We shall show that the algorithm is polynomial for some "hazd" combinations of grammars and inputs. We aze not yet able to prove that the algorithm is polynomial for all grammars and inputs.
A(standard) algorithm for recognition with context-free
gram-mars
In this section I will give a simple algorithm for recognition of sentences generated by a context-free
grammar. The algorithm is based on the algorithms for chazt pazsing that aze described in Gazdar
and Mellish [1989, chap. 6]. The origin of all these algorithms is Eazley's algorithm [Eazley, 1970]. Chart parsing is also described in Winograd [1983, pp. 116-127].
The basic datastructure that is used in the recognizer is the edge. An edge E is a 4-tuple, E- (Vl , VZ, M, T), where
Vl and Vz are integers, M E V`E is a symbol (the mother).
T E V' is a list of symbols (the remainder). T is the list oí daughters that E expects.
Maybe it is good to say that this is a little difl'erent from the edges that Gazdaz and Mellish use. Because we aze not pazsing but recognizing sentences, we are not interested in what has been found yet but only in what has to be found.
Edges aze in fact partial results. In order to apply a rule bottom-up we must have found all its daughters. An edge is an element that says that we have found some daughters of a rule but not all of them. Edges are called inactive when the remainder is empty, otherwise they aze active. The algorithm uses a chazt and an agenda. Both consist of active and inactive edges.
The algorithm we give is a bottom-up algorithm. It consists of two pazts: the scanner and the creator of new edges. The scanner reads one input word and does a lexicon lookup. The result is a set of edges. The edges aze put in the agenda. Then the creator of new edges is stazted. The creator of new edges moves an edge from the agenda to the chart and if the remainder is empty it applies two (meta-) rules on it: the Bottom-up Rule and the F4indamental Rule.
The Bottom-up rule
If you aze adding edge C i, j, A, []~ to the chart, then for every rule in the grammaz of the form B-~ A W, add an edge G i, j, B, W~ to the agendal .
The ~ndamental rule
If you aze adding edge C j, k, B, (] 1 to the chazt, then for every edge in the chazt of the form C i, j, A, [B~W] ~, add a new edge in the agenda of the form G i, k, A,W ~. Both the agenda and the chazt can be seen as sets. They need not be ordered and the creator of new edges can take an azbitrazy edge from the agenda in order to move it to the chazt. In the algorithm, the chazt and the agenda are represented as lists. When we append the newly created
edges at the back of the agenda, we get some kind of breadth-first behaviour. If we append it on
the front, the result is a depth-first behaviour.
INPUT SENTENCE
~~ z add~remove edge """"" z inspection
When the agenda does not contain edges any more, the creator of new edges gives back control to the scanner. The scanner reads the next input word, fills the agenda and new edges can be created again. When there are no input words left anymore, the recognition is almost finished. The algorithm only has to look whether the chart contains an inactive edge with the startsymbol as its mother and which spans the complete input. Appendix A contains the Prolog-code of the algorithm.
The basic algorithm for ACSG
This algorithm is very similaz to the one in the previous section. The definition of an edge is slightly different:
An edge E is a 4-tuple, E- (Vl, Vz, M, T), where
VI and Va are integers, M E V' is a list of symbols (the to-add-list).
T E V' is a list of symbols (the remainder). T is the list of symbols that E expects.
Only M has been changed. In a context-free grammaz, the lefthand-side of a rule is always a single constituent. But now we have rules of the form aZp --~ ayQ. The lefthand-side is a list of symbols (aZ,O) that has to be added in the chazt when the daughters (aryQ) have been found. When M is a list containing one symbol, we call the edge context-free (and otherwise context-sensitive).
The architecture of the system as depicted in Figure 1 remains the same. The creator of new edges takes an edge from the agenda. If it is active, the edge is moved to the chazt and the creator of new edges can take the next edge from the agenda. If the edge is context-free and inactive, the edge is moved to the chazt and the creator of new edges starts applying the meta-rules:
The Bottom-up rule
If you are adding edge G i, j, [A], [] ~ to the chart, then for every rule in the grammaz of the form Wl -~ A Wz, add an edge C i, j,W1,W2 1 to the agendaZ.
The )~ndamental rule
If you are adding edge G j, k, [B], []~ to the chart, then for every edge in the chazt of the form C i, j, WI, [B ~WZ] ~, add a new edge in the agenda of the form C i, k, WI, WZ 1. But what if the edge is context-sensitive and inactive? The creator of new edges has to apply the Split rule now.
~W; are liats of symbols. A and B are symbols.
The Split rule
Take the edge G i, j, Wl, [] 1 from the agenda and put a number of edges back in the agenda. These edges connect new vertices and the symbols one sees walking along the
new path are exactly the symbols in the lefthandside of the applied grammaz rule.
This can be made cleaz with an example. Suppose we have read some input words and we have this chart:
A B C
0 1 2 3
Now we found that the rule E~ B [C] is applicable because we have the inactive
context-sensitive edge G 1, 3, [E, C], []~. The Split rule says we have to put the edges G 1, 4, [E], []~ and
G 4, 3, [C], [] 1 in the agenda. Vertex 4 is a new vertex. 4
0 1 2 3
In the previous section the agenda was organized as a list, but the creator of new edges could
take an arbitrary edge from it (thanks to the fact that all edges in the agenda had the same end
vertex). In this algorithm, we have to be more cazeful. It is obvious that the edge G 1, 4, [E], []~ should be used eazlier to generate new edges than G 4, 3, (C], []~. The edges in the agenda must
be ordered ! It is not very complex to keep the right order in the agenda however: if we apply
the Split rule, we have to append the list of new edges in front of the agenda. The agenda is a FIFO-stack.
When the scanner has read all ínput words, we have to look again in the chart whether there is an inactive edge with the startsymbol as its mother spanning the entire input. The Prolog-code of this algorithm is also in the Appendix, namely in Appendix B.
Problematic grammars
In the previous section a straightforwazd and simple algorithm has been described. The question is whether this algorithm is polynomial and the answer is no.
Consider the grammar: 1 -~ [1] 0
1--~[2]0 2 ~ [1] 0
2--~[2]0
and the input: 100000
i o 0 0 0 0
Obviously the algorithm is not polynomial. This chart, however, is equivalent with the chart: 1, 2 1 0 0 1,2 0 1, 2 0 0
Both chazts contain the same paths. The algorithm we used is too simple and we have to design an algorithm that "collapses edges" when possible.
Refinements of the basic algorithm
The source code of the refined algorithm is in Appendix C. It is an extension of the previous algorithm. I shall describe the changes I made one by one:
~ Left-hand-sides in edges are packed. As a result, there is always at most one complete edge between two points in the agenda and the chart.
~ The agenda is treated as a LIFO-stack. New edges are put on the back. They are taken from the front. We have to be careful with this: Edges that start in, say, V1 have to wait on processing of edges that end in V1. We have to search the agenda till we find the first edge without "predecessor" (fwop). We do not do this when there is already a vertex with
the same outgoing "set of paths".
~ The lefthandsides of edges are packed. Therefore, we have to process a list of list of symbols that have to be added. This is the point where we have to do some collapsing. We search for the longest list in the list of lists. The first symbol of this longest list is the symbol we aze going to add. If necessazy, we create a new vertex and we shift the symbol from all the list stazting with that symbol.
~ I also implemented a graphic output of the pazser which is easier to read than the output of redrau. People who aze interested in it can receive it.
Conclusions
The question is whether the refined algorithm is polynomial. Unfortunately, I have not been able to prove this. I can not think of an invariant restricting the size of the agenda or the chart. In one
or another way, we should use the acyclicity of the grammaz rules. References
Baker, B. S., Non-context-Free Grammazs Generating Context-Free Languages, Inform. and Con-trol, 24, 231-246, 1974.
Book, R. V., Terminal contezt in contezt-sensitive grammazs, SIAM J. Comput., 1, 20-30, 1972. Book, R. V., On the Structure of Context-Sensitive Grammars, Internat. J. Comput. Inform. Sci.,
2, 129-139, 1973.
Book, R. V., On the Complexity of Formal Grammazs, Acta Inform., 9, 171-181, 1978.
Dahlhaus, E. and M. K. Warmuth, Membership for Growing Context-Sensitive Grammazs Is Poly-nomial, Internat. J. Comput. Inform. Sci., 33, 456-472, 1986.
Eazley, J., An Efficient Context-Free Pazsing Algorithm, Comm. ACM, 13(2), 94-102, Feb. 1970. Gazey, M. R. and D. S. Johnson, Computers and Intractability: A Guide to the Theory of
NP-Completeness, W. H. Freeman and Company, San Francisco, CA, 1979.
Gazdaz, G. and C. Mellish, Natural Language Processing in Prolog, Addison Wesley, Reading, MA, 1989.
Ginsburg, S. and S. A. Greibach, Mappings which Preserve Context Sensitive Languages, Inform. and Control, 9, 563-582, 1966.
Hibbazd, T. N., Context-Limited Grammazs, J. Assoc. Comput. Mach., 21(3), 446-453, July 1974. Kazp, R. M., Reducibility among combinatorial problems, in Complexity of Computer
Computa-tions, edited by R. E. Miller and J. W. Thatcher, pp. 85-103, Plenum Press, New York,
1972.
Kuroda, S. -Y., Classes of Languages and Linear-Bounded Automata, Inform. and Control, 7, 207-223,1964.
M5lckinen, E., On Permutative Grammazs Generating Context-Free Languages, BIT, 25, 604-610, 1985.
Appendix A: Context free chart recognition
recognize(String) :-ecan(String,0,[],Chart,Vend), initial(Startsymbol), member(edge(O,Vend,Startsymbol,[]),Chart). scan([],Vend,Finalchart,Finalchart,Vend). scan([WordlWorde],VO,Chartin,Finalchart,Vend) :-V1isVOt1,findall(edge(VO,Y1,Category,[]), Y. lexicon lookup word(Category,Word), lgenda), extend-edges(lgenda,Chartin,Chartout), ecan(Words,Vl,Chartout,Finalchart,Vend). extend-edges([],Finalchart,Finalchart). extend-edges([Edgellgenda],Chart,Finalchart) :-member(Edge,Chart),!, extend-edges(lgenda,Chart,Finalchart). extend-edges([Edgellgenda],Chart,Finalchart) :-create-neu-edges(Edge,Chart,Edges),
'~ add-edges(lgenda,Edges,NeW-agenda), ~ breadth-first processing add-edges(Edges,lgenda,Nes~-agenda), ~ depth-first processing
extend-edges(Neu-agenda,[EdgelChart],Finalchart). create-new-edges(edge(V1,V2,Categoryl,[]),Chart,Edges)
:-findall(edge(V1,V2,Motherl,Tofindl), Y, Bottom-up rule rule(Motheri,[CategoryllTofindl]),
Edgesi),
findall(edge(VO,V2,Mother2,Tofind2), X Fundamental rule member(edge(VO,V1,Mother2,[CategoryllTofind2]),Chart),
Edges2),
append(Edgesl,Edges2,Edges).
create-neW-edges(edge(V1,V2,Categoryl,[Category2lTofind]),Chart,[]).
add-edges([],Edges,Edges). Í add-edges - add unless it is a member add-edges([EdgelEdges],Edgesl,Edges2) :-member(Edge,Edgesl),!, add-edges(Edges,Edgesl,Edges2). add-edges([EdgelEdges],Edgesi,[EdgelEdges2]) :-add-edges(Edges,Edgesl,Edges2). ?indall(Item,Goal,Items)
:-bagof(Item,Goal,Items),!. Y. built-in predicate, collects Items
findall(I,G,[]). Y satisfying Goal
y, rule(s,[np,vp]). w~rd(np,k'-m). initial(s). '~ example rules, lexicon, startsymbol
Appendix B: Acyclic Context Sensitive chart recognition
recognize(String)
:-retractall(hvn(-)), X hvn - Highest Vertex Number
assert(hvn(0)), scan(String,0,[],Vend,Chart), initial(Startsymbol), member(edge(O,Yend,[Startsymbol],[]),Chart). scan([],Vend,Finalchart,Vend,Finalchart). scan([WordlWords],VO,Chartin,Vend,Finalchart) :-freshnumber(Vi), Iindall(edge(VO,V1,[Category],[]), vord(Category,Word), Agenda), extend-edges(Agenda,Chartin,Chartout), scan(Words,Vl,Chartout,Vend,Finalchart). extend-edges(C7,Finalchart,Finalchart). extend-edges([Edgel~genda],Chart,Finalchart) :-member(Edge,Chart),!, extend-edges(Agenda,Chart,Finalchart). extend-edges([EdgelAgenda],Chart,Finalchart)
:-Edge - edge(VO,V1,[Category],[]),!, ~ inactive, context-free create-neu-edges(Edge,Chart,Edges),
add-edges(Edges,Agenda,Necr-agenda),
extend-edges(New-agenda,[EdgelChart],Finalchart). extend-edges([Edgel~genda],Chart,Finalchart)
:-Edge - edge(VO,Y1,Toadd,[]), ~, inactive, context-sensitive split(YO,V1,Toadd,Edges),
add-edges(Edges,Agenda,Necr-agenda),
extend-edges(Nev-agenda,Chart,Finalchart). extend-edges([EdgelAgenda],Chart,Finalchart)
freshnumber(J) :- '~ generate fresh vertex number hvn(I), JisIti, retract(hvn(I)), assert(hvn(J)),!. create-nev-edges(edge(V1,V2,[Category],[]),Chart,Edges)
:-tindall(edge(Y1,V2,Toaddl,Tofindl), X Bottom-up rule init(Category,Toaddl,Tofindl),
Edgesi),
findall(edge(VO,Y2,Toadd2,Tofind2), y. Fundamental rule member(edge(VO,V1,Toadd2,[CategorylTofind2]),Chart), Edges2), append(Edgesl,Edges2,Edges). init(Category,Toadd,Tofind) :-rule(Lhs,Context-left,Rhs,Context-right), append3(Context-left,Rhs,Context-right,[CategorylTofind]), append3(Context-left,[Lhs],Context-right,Toadd).
X append3 appends 3 lists (trivial)
'~ rule(s, [] , [ap,vp] , C] ) . Word(np,kim) . initial(s) .
Appendix C: Refined Acyclic Context Sensitive chart recognition
recognize(String)
:-retractall(hvn(-)), assert(hvn(0)),
next-vord(String,0,[],Chart,-),!, Write('I start draving !'),nl, redrau(Chart). next-word([],Vend,Finalchart,Finalchart,Vend). next-WOrd([WordlWords],VO,Chartin,Finalchart,Vend) :-ireshnumber(V1), findall(edge(VO,V1,[[Category]],~), pord(Category,Word), Agenda), extend-edges(lgenda,Chartin,Chartout),!, next-vord(Words,Vi,Chartout,Finalchart,Vend). extend-edges([],Finalchart,Finalchart). extend-edges(Agenda,Chart,Chart3) :-fwop(ágenda,Agenda2,F,Agenda), extend-edges2(F,Agenda2,Chart,Chart3). y. First element of a list WithOut Predecessor
splitgraph(edge(B,E,Lol,[]),Listoiedges,lgenda) :- Y Loe max 3 BK KE BE searchlongest(Lol,[FIUit],[],0),
Uit `-- [].!.
extract(F,Lo1,Lo12,Lo13), 'G 2 K-E, 3 B-E
sort(Lo12,Lo12s),sort(Lo13,Lo13s),
checkpack(B,E,F,Lo12s,Lo13s,1genda,Listofedges).
splitgraph(edge(B,E,Lol,[]),Listotedges,-) :-singlestosingles(B,E,Lo1,Listofedges).
extract (-, [] , [] , [] ) .
extract (F, [ [F I Ri] I R2] , [Ri IUitlist] ,K) : -R1 `~S U .!, extract(F,R2,Uitlist,K). extract(F,[[F21R1]IR2],K,[[F21R1]IUitlist]) :-extract(F,R2,K,Uitlist). checkpack(B,E,F,Lo12,Lo13,lgenda,[edge(B,E,Lo13,[]),edge(B,K2,[[F]],[])]) :-Lo13 `-- [] , member(edge(K2,E,Lo12,[]),Agenda). checkpack(B,E,F,Lo12,[],Agenda,[edge(B,K2,[[F]],[])]) :-member(edge(K2,E,Lo12,[]),lgenda). checkpack(B,E,F,Lo12,Lol3,lgenda, [edge(B,E,Lo13,[]),edge(B,K,[[F]],[]),edge(K,E,Lo12,[])]) :-Lol3 `-- [], `t member(edge(-,E,Lo12,[]),Agenda), treshnumber(K). checkpack(B,E,F,Lo12,[],lgenda, [edge(B,K,[[F]],[]),edge(K,E,Lo12,[])]) :-`f inember(edge(-,E,Lo12,[]),lgenda), ireshnumber(K). singlestosingles(-,-,[],[]). singlestosingles(B,E,[[F]IR2],[edge(B,E,[[F]],[])IUitlist]) :-singlestosingles(B,E,R2,Uitlist). new-edges(edge(V1,V2,[[Category]],[]),Chart,Edges):-tindall(edge(V1,V2,[Toaddi],Toiindi),
XY.Y.Y.'~.Y,GX XY.Y.Gy.'~Y.Y.Y.'l.'~'~'~'LY.Y. i'~Y.X'~.X X XY.i'LY.'~ Y.Y.'GY.XY.X Y.'~Y.Y.'~.'~'~'~'~'~'~.Y.'l. X eifect is: add-edges(I,B,C) :- append(B,A,C)
y. second argument (B) has already been packed Y. C will be packed again
Y.'I.X'I.XY.Y.XY.Y.YX'l.y,'I.Y.X'l.'l,'l.'l.'I.7Y.YXY.Y,Y.Y'I.Y.Y.'I.Í'l.XY.Y.Y.Y.Y.X'I.Y.XY.~XY,Y.~Y.Y. X'I,X
add-edges([],Edges,Edges). add-edges([EdgelEdges],Edgesl,Edges2) :-member(Edge,Edgesl),!, add-edges(Edges,Edgesi,Edges2). add-edges([EdgelEdges],Edgesl,Edges2):-packlhs(Edge,Edgesl,Edges5),!, add-edges(Edges,Edges5,Edges2).packlhs (E, [] , [E] ) .
