| { |
| "paper_id": "J76-1003", |
| "header": { |
| "generated_with": "S2ORC 1.0.0", |
| "date_generated": "2023-01-19T02:52:19.720016Z" |
| }, |
| "title": "MAKOTO NAGAO AND JUN-ICHI TSUJII", |
| "authors": [], |
| "year": "", |
| "venue": null, |
| "identifiers": {}, |
| "abstract": "PLATON (Programming LAnguage for Tree OperatioN) facilities of pattern matching and flexible backtracking, language is developed t~ simplify writing analysis programs The pattern matching process has the facility t o extract subinput sentence and invoke semantic and contextual checking fo?. actions between syntactic and other components are easily obt processing r e s u l t s i n a failure, a message which expresses t : failure will be sent up. The control w i l l be modified accoru enables us t o write f a i r l y complicated non-deterministic progr manner. An example of structural analysis using PLATON is a l s", |
| "pdf_parse": { |
| "paper_id": "J76-1003", |
| "_pdf_hash": "", |
| "abstract": [ |
| { |
| "text": "PLATON (Programming LAnguage for Tree OperatioN) facilities of pattern matching and flexible backtracking, language is developed t~ simplify writing analysis programs The pattern matching process has the facility t o extract subinput sentence and invoke semantic and contextual checking fo?. actions between syntactic and other components are easily obt processing r e s u l t s i n a failure, a message which expresses t : failure will be sent up. The control w i l l be modified accoru enables us t o write f a i r l y complicated non-deterministic progr manner. An example of structural analysis using PLATON is a l s", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Abstract", |
| "sec_num": null |
| } |
| ], |
| "body_text": [ |
| { |
| "text": "The ATN model has the following additional merits : .", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Thc augmcn t c d t r i 1 1 1~ i L I o n ilc twork (A1l'N) proposccl by W Woods (19 70) from our p o i n t of view gives an e s p e c i a l l y good framework for natural Xa~~guage a n a l y s i s systems. One of-t h e most a t t r a c t i v e features is t h e clear dtscrimination between grammatical rules and t h e control mechanism. T h i s enables us t o develop t h e model by adding various f a c i l i t i e s t o its control mechanism.", |
| "sec_num": null |
| }, |
| { |
| "text": "x p r e s s i o n e q u i v a l e n t t o t r a n s f o r m a t i o n a l grammars 2.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "It p r o v i d e s power of e", |
| "sec_num": "1." |
| }, |
| { |
| "text": "I t mai11tai.n~ much of the r e n d a b i l i t y of context-free grammars.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "It p r o v i d e s power of e", |
| "sec_num": "1." |
| }, |
| { |
| "text": "3 . R u l e s of n grammar can b e changed easily, so we can improve them through a t r i a l -a n d -e r r o r process whi1.e w r i t i n g t h e grammar.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "It p r o v i d e s power of e", |
| "sec_num": "1." |
| }, |
| { |
| "text": "of s e m a n t i c and p r a g m a t i c c o n d i t i o n s on the b r a n c h e s between s t a t e s . By d o i n g this, c l o s e i n t e r a c t i o n s between the s y n t a c t i c and other components can b e e a s i l y accomplished.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "I t i s p o s s i b l e t o impose various types", |
| "sec_num": "4." |
| }, |
| { |
| "text": "However ATN h a s the f o l l o w i n g s h o r t c o m i n g s , e s p e c i a l l y when we a p p l y i t to the p a r s i n g of Japanese s e n t e n c e s :", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "I t i s p o s s i b l e t o impose various types", |
| "sec_num": "4." |
| }, |
| { |
| "text": "1. It scans words one-by-one from the leftmost end of an input s e n t e n c e , checks t h e a p p l i c a b i l i t y of a r u l e , and makes t h e t r a n s i t i o n from one s t a t e t o a n o t h e r . This method may b e w e l l s u i t e d for E n g l i s h s e n t e n c e s ,", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "I t i s p o s s i b l e t o impose various types", |
| "sec_num": "4." |
| }, |
| { |
| "text": "but b e c a u s e t h e o r d e r of words and p h r a s e s i n Japanese s e n t e n c e s is r e l a t i v e l y free, i t is preferable t o check t h e a p p l i c a b i l i t y o f a r u l e by a flexible p a t t e r n -m a t c h i n g method. I n a d d i t i o n , w i t h o u t a p a t t e rn-matching mechanism, a s i n g l e rewriting r u l e of an o r d i n a r y grammar i s often to b e expressed by several rules belonging to d i f f e r e n t s t a t e s i n Woods ATN parser.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "I t i s p o s s i b l e t o impose various types", |
| "sec_num": "4." |
| }, |
| { |
| "text": "2. An ATN model e s s e n t i a l l y performs a k i n d of top-down analysls of s e n t e n c e s . T h e r e f o r e recovery f ronl f a i l u r e s in p r e d i c t f . o n is most d1.f f i c u l t . ", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "I t i s p o s s i b l e t o impose various types", |
| "sec_num": "4." |
| }, |
| { |
| "text": "A grammar, whether g e n e r a t i v e o r a n a l y t i c a l . i s r e p r e s e n t e d as a (2) a c t i o n s which must be executed, i f the r u l e is a p p l i c a b l e", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Basic O p e r a t i o n s of PLATON", |
| "sec_num": "111" |
| }, |
| { |
| "text": "(3) a s t r u c t u r a l p a t t e r n i n t o which the i n p u t s t r u c t u r e s h o u is found, the i n p u t s t r u c t u r e is transformed i n t o a n o t h e r s t r u c t u r e s p e c i f i e d by t h e r u l e and the control makes the s t a t e t r a n s i t i o n . , when i t i s a p p l i e d . ", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Basic O p e r a t i o n s of PLATON", |
| "sec_num": "111" |
| }, |
| { |
| "text": "> i s ( ( A ( R1 (# C D E B ) ) ( R2 ( G ( R3 H ) ) ) ) F G ) .", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Basic O p e r a t i o n s of PLATON", |
| "sec_num": "111" |
| }, |
| { |
| "text": "I f the r u l e is a POP-type one, then this s t r u c t u r e w i l l be returned t o t h e h i g h e r level processing. If i t is NEXTor NEXTB-type, then the c o n t r o l w i l l The v a r i a b l e :I1 is bound to tius i n t e g e r . This i n t e g e r i s added t o t h e sum of the i n t e g e r s , :N, i f the t o t a l does n o t exceed t e n (SUMUP -I-, con). ", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "Basic O p e r a t i o n s of PLATON", |
| "sec_num": "111" |
| } |
| ], |
| "back_matter": [ |
| { |
| "text": "structure under processing = (# (X (SUM 9)) 2 2 (X (SUM 0)) ) And /REG and /RESULT are set as the following (BACKTRACK -1-, act) .The transformed structure is (BACKTRACK -10, end)The control is transferred to the s t a t e SUMUP. By applying t h e f i r s t rule of t h i s s t a t e repeatedly on t h e above structure the f o l l o w i n g structure is obtained.However this result does not s a t i s f y t h e con textual restriction.", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "annex", |
| "sec_num": null |
| }, |
| { |
| "text": "CONTEXTCHECK used i n <con ) -part r e t u r n s the value NIL (SUMUP -2-, con)That is :The third rule, therefore, ", |
| "cite_spans": [], |
| "ref_spans": [], |
| "eq_spans": [], |
| "section": "So the application of t h e second r u l e of SLJMl. JP f a i l s because t h e f u n c t i o n", |
| "sec_num": null |
| } |
| ], |
| "bib_entries": {}, |
| "ref_entries": { |
| "FIGREF0": { |
| "text": "T r a d i t i m a 1 systems whi.ch r e p r e s e n t grammars a s a s e t of r e w r i t i n g rules u s t i a l l y 'have poor c o n t r o l mechanisms, and flexible i n t e r a c t i o n between thc s y n t a c t LC and other con~ponents is n o t possible. Systems in which r u l e s o f gr-;lnmlilrs . r l r c cn11,i-dilcd i n proccdrlrcs, a n . tllc other hand, make it p o s s i b l c t o i n t t -r m i s ttrct 6 yrltnc t 'lc and seniant i c a n a I y s t ? s i n an i r~tiinnte way. Llowcvcr, thest. s y s t c o s are apt. t . 0 c.lestroy the i n t c . l l i g i h : i l ity and r e g u l a r i t y o f n a t u r a l language gramars, because i n these systems b o t h r u l e s and their c o n t r o l mechanisms are contained i n the same program. Recently various syscems for natural language a n a l y s i s have been developed T . Winograd's (1971) \"PROGRAMMAR\" i s a t y p i c a l example of procedure oriented systems. In this system the syntactic and other components can interact c l o s e l y i n the course of analyzing sentences. However, d e t a i l s o f the program are lost i n the r i c h n e s s o f this i n t e r a c t i o n . LINGOL, developed by V . Pratt (1973) a t MIT, i s a language appropriate t o syntaxsemantics interface and in which it is easy t o write grammars in t h e form of rewriting r u l e s . The TAUM group a t Montreal University (1971) has evolved a programming languagc name :I System-Q in which expressions of t r e e s , strings and lists o f them can b e matched against p a r t i a l expressions ( s t r u c t u r a l patterns) c o n t a i n i n g variables and can be transformed i n any a r", |
| "uris": null, |
| "num": null, |
| "type_str": "figure" |
| }, |
| "FIGREF1": { |
| "text": "these f a c t o r s , w e d e v e l o p e d PLATON (a Programming Lhnguage f o r Tree-Ol>cratioN), which is b a s e d on the A1'N model and has v a r i o u s a d d i t i o n a l c a p a b i l i t i e s such as pattern-matching, f l e x i b l e b a c k t r a c k i n g , and s o on. As in S y s t e w Q and LINGOL, PLATON's pattern-matching f a c i l i t y makes i t e a s y to write rewriting r u l e s . Moreover, i t extracts s u b s t r u c t u r e s from the i n p u t s and invokes a p p r o p r i a t e semantic a n d c o n t e x t u a l checking f u n c t i o n s .", |
| "uris": null, |
| "num": null, |
| "type_str": "figure" |
| }, |
| "FIGREF2": { |
| "text": "These may be arbitrary LISP functions d e f i n e d by t h e user, the arguments of w h i~n are t h e extracted s u b s t r u c t u r e s .A backtracking mechanism is a l s o necessary for l a n g u~e understandingasin other fields of a r t i f i c i a l intelligence. During t h e analysis, various sorts of h e u r i s t i c information should be u t i l i z a b l e . A t any s t a g e , analysis based on criteria which may r e l a t e t o syntactic, semantic or contextual considerat ions taken separately may be u n r e l i a b l e . The result which f u l f i l s all the criteria, however, w i l l b e a correct one. The program s h o u l d b e designed s u c h that i t can choose the most satisfactory rule from many c a n d i d a t e s according t o the criteria at hand. In further processing, i f the choice i s found t o b e wrong by other criteria, t h e program must be able t o backtrack t o the p o i n t at which the .relevant decision w a s made. In PLATON we can e a s i l y s e t up arbitrary numbers of d e c i s i o n p o i n t s in t h e program. Then, i f subsequent processing r e s u l t s i n some failure, control w i l l come back t o the points relevant t o the cause of the f a i l u r e . 11. Pattern-matching Before proceeding t o the detailed description of PLATON, w e w i l l explain t h e r e p r e s e n t a t i o n schema for i n p u t sentences and parsed trees. The process of analyzing a sentence, roughly speaking, may be regarded as the process of transforming an ordered list of words t o a tree s t r u c t u r e , which shows e x p l i c i t l y the interrelationships of each word in the input sentence. During the process, trees which correspond to the parts already analyzed, and 1 h t s which have not been processed y e t , may c o e x i s t together i n a s i n g l e s t r u c t u r e . We therefore wish to represent such a coexisting structure o f trees and lists. A l i s t structure is a s t r u c t u r e i n which the order of element i s not changeable. On the other hand, a tree structure c o n s i s t s of a single root node and several nodes which are tied t o the root node by d i s t i n g u i s h a b l e r e l a t i o n s . Because relations between the root and the other nodes are e x p l i c i t l y s p e c i f i e d , t h e order of nodes in a tree is changeable except for the root node which is placed in the leftmost position. Different matching schemas w i l l be a p p l i e d t o trees and lists. The formal definition of such coexisting structures is as f o l l o w s . <structure> i s the fundamental data-structure into which a l l data processed by PLATON must be transformed. Hereafter we refer t o this as the \"structure\" The formal definition of <structure) is: : := C l i s t > I !UBITRARY LISP-ATOM < relation > : := ARBITRARY LISP-ATOM A simple example is shown in Figure 1. Expression of Structure i n PLATON Two l i s t s which have the same elements but d i f f e r e n t orderings (for example, ( X A B C) and ($ A C B)) , should be regarded as different structures. On the other hand, two tree structures s u c h as ( A ( R1 B ) ( R2 C ) ) and ( A ( R2 C ) ( R1 B ) ) are regarded as i d e n t i c a l . Besides the usual rewrite rules which treat such s t r i n g s , s tructural p a t t e r n s which c o n t a i n variable expressions are permitted in PLATON. The PLATON-interpreter matches structural patterns containing variable expressions against the structure under process a n d checks whether the s p e c i f i e d p a t t e r n is found in it. At the same time, t h e variables in the pattern are bound t o the corresponding subs tructurzs . Variables i n patterns are indicated as :X (X i s an arbitrary LISP atom). The following can be expressed by variables in the above definition (1) arbitrary numbers of < structures> , that i s to say, l i s t elements in the definition of < list > ( Illustration of Matching number of l i s t elements by i n d i c a t i n g variables as :X+number. For example, t h e variable :D2 w i l l match with two elements in a list.(2) arbitrary numbers of <branches > , i n t h e definition of (tree > tree) in the d e f i n i t i o n of < branch)(Figure 2, Ex. 3 ).W e s h a l l fail such s t r u c t u r a l p a t t e r n s ( s t r u c t u r e -1 > . By using the same variable several times i n a p a t t e r n , we can express a structure i n w h i c h t h e same sub-structure appears i n two o r more different places. The c h a r a c t e r ! i n a l i s t indicates that t h e n e x t e l e m e n t following t h e c h a r a c t e r i s o p t i o n a l .", |
| "uris": null, |
| "num": null, |
| "type_str": "figure" |
| }, |
| "FIGREF3": { |
| "text": "d i r e c t e d graph with labeled s t a t e s and branches. There is one state d i s tinguished as the Start S t a t e and a s e t of s t a t e s called F i n a l S t a t e s . Each branch i s a rewriting r u l e and has the following elements: (1) applicability c o n d i t i o n s of t h e rule, t y p i c a l l y r e p r e s e n t e d as a structural p a t t e r n", |
| "uris": null, |
| "num": null, |
| "type_str": "figure" |
| }, |
| "FIGREF4": { |
| "text": "a t e has several branches ordered according t o the p r e f e r e n c e of tho rules. When the control jumps t o a s t a t e , i t checks t h e rules associated with the s t a t e one-by-one until it finds an a p p l i c a b l e rule. If such a rule", |
| "uris": null, |
| "num": null, |
| "type_str": "figure" |
| }, |
| "FIGREF5": { |
| "text": "i t i o n t o the above basic mechanism t h e system i s provided with push-down and pop-up operations. The push-down o p e r a t i o n i s such that i n t h e process of a p p l y i n g a r u l e , several s u b s t r u c t u r e s are extracted from the whole s t r u c t u r e by v a r i a b l e b i n d i n g mechanisms of pattern-matching. Then each i s analyzed from a d i f f e r e n t state. The pop-up operation i s such that after each substructure i s analyzed appropriately, control comes back to the suspended r u l e and execution continues. Usills these operations, embedded s t r u c t u r e s can b e handled e a s i l y (See Figure 3) .F i p u r e 3 S t a t e Diapram Table 1 shows the formal d e f i n i t i o n cf a grarmr of PLATON (See followi n g page). It shows t h a t branches or rewriting rules in an ATN parser correspond to six-tuples ( i e., ( p c o n ) , < s t r x > , dcon> , ( c t r a n s r ) , ( 4 a c t s > ) , dendb . < s t r x > corresponds to the left side of a rewriting rule and describes the s t r u c t u r a l pattern t o which a rule is applicable. ( strx > i s , by d e f i n i t i o n (1) / or ( ( pcon) cstrx, <con> ( <trans> ( 4 acts? tend 3 ) < trans> .. . . = I < t r a n s i 0 C trans, Iregister-name, < transit, : : = ( ( (state-name , <structure-2> ) derrorps) 4 variable-nam-4 pros, .. -. . -<pro> I < p r o > 4 pros> 4 pro > .. = .. (EXEC < t r a n s > ) I(TRANS ( (state-name> 4 s t s y > ) ) ( e n d '> .. .. = (NEXT estate-name) <stry> I (NEXTB 4 s ta te-name> rstry 2 ) ((POP 4 stry> ) I (FM < failure-message ) .facts> .. . . = I 4 a c t > < a c t s > <set > : : = <form , I (SR (register-name> d form> I (SU 4 regis ter-name > < form > ) ~( S D <register-name > cf orm. ) < strx > .. (GR .<register-name> ) I (GV (variablename > ? ~( T R structure-2. ) I(TR / ) 1 ARBITRARY LISP FORM <variable-:: = :X (X is an arbitrary LISP atom) name 7 <register-: : = /X (X is an arbitrary LISP atom) name) shows t h a t a r u l e i s a p p l i c a b l e no matter what the s t r u c t u r e under process i s The v a r i a b l e s used i n ( s t r u c t u r e -1 ) are bound t o c o r r e s p o n d i n g s u b s t r u c t u r e s when matching succeeds. The results of Example 1 (See Figure 2 ) i n d i c a t e that the v a r i a b l e :K i s bound t o the s u b s t r u c t u r e (* ( B ( R1 C)) D ) The scope of v a r i a b l e binding i s l i m i t e d t o w i t h i n t h e realm of the particular r u l e . The same variable name i n d i f f e r e n t r u l e s has d i f f e r e n t i n t e r p r e t a t i o n s . I n t h i s sense, :X-type v a r i a b l e s i n < s t r u c t u r e -I > are c a l l e d Local Variables. On t h e o t h e r hand, w2 can s t o r e c e r t a i n kinds of res u l t s from the application of rules in registers and refer back t o them i n d i f f e r e n t r u l e s . These cons tftue variables which we c a l l r e g i s t e r s . They a r e r e p r e s e n t e d by t h e symbols / X (X is an a r b i t r a r y LISP atom). Besides the pattern-matching, < peon> and < con ) can .~l s o check the a p p l i c a b i l i t y of a rule. Certain parts of the results from the applicat i o n of p r e v i o u s rules are c o n t a i n e d i n r e g i s t e r s , n o t in the s t r u c t u r e . We can check the c o n t e n t s of t h e s e r e g i s t e r s by using < pcon > -part functions like GR, GU, e t c . (these f u n c t i o n s are l i s t e d i n Table 2) and o t h e r LISP functions d e f i n e d by the usual LISP function, DEFINE. (See following page for Table 2 . ) Semantic and c o n t e x t u a l c o -o r d i n a t i a n between s u b s t r u e t u r e s can b e checked by using appropriate functions in the (con > -p a r t o f a r u l e . Semantic and contextual analyses cannot be expressed in the form of s i m p l e r e w r i t i n g rules. These analyses have differing requirements such as l e x i c a l information about words which may in turn represent knowledge of t h e world and contextual i n f o r m a t i o n which may. express t h e s t a t e of the world. We can use arbitrary LISP-forms i n the 4 con 7 -part, according to what semantic and contextual models we choose.", |
| "uris": null, |
| "num": null, |
| "type_str": "figure" |
| }, |
| "FIGREF6": { |
| "text": "Effect SR s t o r e s the r e s u l t of the evaluation of the 2nd argument i n the r e g i s t e r . SV s t o r e s the result of the evaluation of t h e 2nd argument i n the v a r i a b l e GR g e t t h e content of the r e g i s t e r GV g e t s the value of t h e TR transforms t h e v a r i z b l e s and r e g i s t e r s i n t h e s t r u ct u r a l p a t t e r n i n t o t h e i r values. SU sets the reigster of t h e higher level processing SD sets t h e r e g i s t e r of t h e the transformed s t r u c t u r e the result of the evaluation of the 2nd argument I lower l e v e l processing.GU g e t s t h e content of the register of the higher level. PUSHR is defined as the following. (SR r regis ter-name> (CONS 4 form, (GR < r e g i s t e r -name3 1 1) the r e s u l t of t h e e v a l u a t i o n of t h e 2nd argument the content of the r e g i s t e r the result of the e v a l u a t i o n of t h e 2nd argument For example, suppose s t r x = ( ADJ ( TOK :N ) ) ( N(TOK : N 1 ) ) :I ) con = ( SEM :N : N 1 ) Here TOK is the l i n k between a word and i t s p a r t of speech. :N and : N 1 are t h e words o f an i n p u t s e n t e n c e . SEM i s a f u n c t i o n d e f i n e d by t h e u s e r which checks t h e s e m a n t i c c o -o r d i n a t i o n between t h e a d j e c t i v e :N and t h e noun :N1. By t h i s f u n c t i o n SEM, w e can s e a r c h , i f n e c e s s a r y , through b o t h l e x i c a l entries and the contextual d a t a bases. U i t h t h i s approach, i f a c e r t a i n s y n t a c t i c p a t t e r n is found i n t h e input s t r u c t u r e , i t i s p o s s i b l e f o r an a p p r o p r i a t e semantic r u n c t i o n t o b e c a l l e d . Hence t h e i n t i m a t e i i i t c r c c t i o n s between s y n t a c t i c and s e m a n t i c components can b e o b t a i n e d easily w i t h o u t d e s t r o y i n g the clarity o f n a t u r a l language grammars. A r b i t r a r y LISP-forms can be a l s o used i n < a c t > -p o r t i o n . They w i l l b e e v a l u a t e d when t h e r u l e is a p p l i e d . I f n e c e s s a r y , w e can s e t i n t e r m e d i a t e r e s u l t s i n t o r e g i s t e r s and v a r i a b l e s by u s i n g t h e f u n c t i o n s l i s t e d i n Table 2 ( e n d > comprises f~u r v a r i e t i e s , and r u l e s are divided i n t o four t y p e s a c c o r d i n g t o t h e i r ( end > t y p e s . 1. NEXT-type : The < end+ i s i n t h e form (NEXT dstate-name, 4 s try> ) . The b s t r y ) c o r r e s p o n d s t o t h e r i g h t s i d e o f a r e w r i t i n g r u l e , and r e p r e s e n t s t h e transformed s t r u c t u r e . A r u l e of this type c a u s e s s t a t e -t r a n s i t i o n t o t h e d s t a t e -n a m e )", |
| "uris": null, |
| "num": null, |
| "type_str": "figure" |
| }, |
| "FIGREF7": { |
| "text": "2. NEXTB-type:This r u l e a l s o c a u s e s state-transition. Unlike w i t h the NEXT-type, s t a t e -s a v i n g is done and i f f u r t h e r p r o c e s s i n g r e s u l t s i nsome f a i l u r e s , c o n t r o l comes back t o t h e s t a t e where t h i s r u l e i s a p p l i e d . The environments, t h a t i s , t h e c o n t e n t s of v a r i o u s r e g i s t e r s w i l l be r e s t o r e d , and t h e n e x t r u l e b e l o n g i n g t o t h i s s t a t e w i l l b e t r i e d 3. POP-type : The (end > -part of t h i s type is in the form (POP < s try > ) When i t is applied, t h e processing of this l e v e l is ended and the c o n t r o l r e t u r n s t o t h e h i g h e r l e v e l with t h e v a l u e s t r y > . 4 . FM-type: The <end ) -p a r t of this t y p e i s i n t h e form (FM <failuremessage) ) . The s i d e e f f e c t s of he processing a t t h i s l e v e l , t h a t i s , r e g i s t e r s e t t i n g s and s o on, a r e c a n c e l l e d (see s e c t i o n 4 ) . I n < s t r y > we can use two kinds of variables, t h a t i s , the variables used i n d s t r x > and r e g i s t e r s . W e f i n d t h i s s t r u c t u r a l p a t t e r n , c a l l e d 4 s t r u c t u r e -2 > , more s u i t a b l e f o r w r i t i n g t r a n s f o r m a t i o n a l r u l e s than Woods BUILDkoperation. By way of i l l u s t r a t i o n c o n s i d e r the following: (A ( F U (* :I :N ) ) ( R2 /REG ) ) :J) t h e c o n t e n t of /REG = ( G ( R3 H ) ) A s t h e r e s u l t of matching, t h e v a r i a b l e s :I, :N and :J a r e bouad t o the s u b s t r u c t u r e s (& C D E ) , ($ B) and (3 F G ) r e s p e c t i v e l y . The r e s u l t of e v a l u a t i n g t h e < s t r y", |
| "uris": null, |
| "num": null, |
| "type_str": "figure" |
| }, |
| "FIGREF8": { |
| "text": "move t o t h e s p e c i f i e d s t a t e with t h i s s t r u c t u r e .", |
| "uris": null, |
| "num": null, |
| "type_str": "figure" |
| }, |
| "FIGREF9": { |
| "text": "Push-down and Pop-up Operations By means of NEXTB-type r u l e s , w e can s e t up decision p o i n t s i n a program. W e can a l s o do this by using push-down and pop-up operations. A r u l e i n PLATON f i n d s particular s y n t a c t i c c l u e s by i t s s t r u c t u r a l d e s c r i p t i o n", |
| "uris": null, |
| "num": null, |
| "type_str": "figure" |
| }, |
| "FIGREF10": { |
| "text": "strx> ; and a t the same time, e x t r a c t s substructures from the input st'king From the structural description i t i s predicted that the substructures may have particular constructions, that i s , t h e y may comprise noun phrases, relative clauses or whatever. It is-necessary to transfer the s u b s t~r~c t u r e s t o s t a t e s appropriate f o r analyzing these constructions predicted and to return the analyzed structures back into the appropriate places In PLATON, these operations can be described in the Ctrans > -part o f a rule. For example, suppose the <trans >-part of a rule is ( ( ( Sl :K :K ) ) ( ( S2 ( :I :J)/REG ) ) ) When the cantrol interprets t h i s statement, the substructures corresponding t o the v a r u b l e :K and ( :I : J ) are transferred t o the s t a t e s S1 and S 2 respectively If the p r o c e s s i n g s starting from these s t a t e s are normally completed (by a POP-type r u l e ) , then the r e s u l t s are stored i? the variable :K and the regzster /REG. In this manner, by means of the push-down and pop-up mechanisms, substructures can be analyzed from appropriate states. Processing from k e s e s t a t e s , however, may sometimes result in failure, That i s , predictions that certain relationships w i l l be found among the elements of substructures may not be f u l f i l l e d . In such instances the pushed down state w i l l send an error-message appropriate t o the cause of the failure by an W t y p e rule. An FM-type rule points o u t that a certain error has occurred in the processing. If NEXTB-type rules were used i n the previous processing a t this l e v e l , control w i l l go back t o the most recently used NEXTB-type r u l e . If NEXTB-type rules were not used at this processing l e v e l , tne error-message specified by the FM-type rule w i l l be sent t o the <trans> part of the rule which directed this push-down operation (seeFigure 4)e will be applied n e x t .", |
| "uris": null, |
| "num": null, |
| "type_str": "figure" |
| }, |
| "FIGREF11": { |
| "text": "Illustration of Backtracking43According t o these error-messages, control-flow can be changed appropriately. For example, w e can direct processings by describing the 4 trans > -part i n the following way.( ( ( sl :K :K ) ( ERR1 ( EXEC ( ( S5 :K :K 1) ( ( 56 ( :I :J ) /REG ) ) ) ) ( ERR2 ( T U N S ( S8 / ) ) I ( ( S 2 (j6 : I :J ) /REG ) ) )I n t h e above example, the processing of the substructure :K from the s t a t eS1 will produce one of t h e f o l l o w i n g three r e s u l t s . According to the returned value, the appropriate step w i l l b e taken: (1) Normal return: the processing of :K is ended by a POP-type rule. The r e s u l t i s s t o r e d i n the variable :K and the n e x t push-down performed, that i s : I : J ) w i l l be transferred t o the s t a t e S2. Return w i t h an error-message: t h e processing of : K results in a f a i l u r e and an FM-type r u l e sends up an error-message. If t h e message is ERR1, them :K and :f :J ) w i l l b e analyzed from the s t a t e s S5 and S6 respectively (EXEC-type). If i t i s ERRS, the i n t e r p r e t e r w i l l give up t h e application o f the p r e s e n t rule, and pass the control to another s t a t e S8 (TRANS-t y p e ) . If it is neither ERRl nor ERR2, t h e same s t e p as (3) w i l l be taken Re turn w i t h the value NIL: the processing Prom t h e state S1 w i l l send up the value NIL if it runs into a blind alley, that is, there are no a p p l i c a b l e r u l e s . The interpreter w i l l give up the a p p l i c a t i o n of the p r e s e n t rule and proceed to the next rule attached t o t h i s s t a t e . Mechanisms, such that control flow can be appropriately changed according to the error-messages from lower level processings are n o t found in Woods ATN parser, W e can obtain flexible backtracking f a c i l i t i e s by combining these mechanisms w i t h NEXTBtype rules. V A S i m p l e Example W e are now d e v e l o p i n g a d e d u c t i v e question-answering sys tern with n a t u r a l language i n p u t s --J a p a n e s e sentences. The i n t e r n a l data-base is assumed t o be a s e t o f deep case s t r u c t u r e s o f i n p u t s e n t e n c e s . W e a d o p t e d and m o d i f i e d Fillmore's (1968) case grammar t o analyze the i n p u t of J a p a n e s e s e n t e n c e s . Japanese i s a t y p i c a l example o f a n SOV-language i n which t h e o b j e c t and o t h e r c o n s t i t u e n t s governed by a verb usually appear b e f o r e :he verb i n s sentence. A typical c o n s t r u c t i o n of a Japanese sentence i s shown in F i g u r e 5 .", |
| "uris": null, |
| "num": null, |
| "type_str": "figure" |
| }, |
| "FIGREF12": { |
| "text": "y p i c a l Construction of a Japanese Sentence A verb may govern several noun phrases preceding it. A relative clause modifying a noun may a p p e a r i n t h e form --verD + noun --The r i g h t boundary of t h e clause is easily identified by f i n d i n g the verb. The left boundary i s o f t e n much more d i f f i c u l t t o i d e n t i f y . I n F i g u r e 5, t h e noun phrase N P k r i s a c a s e element of t h e verb V On the o t h e r hand, t h e noun", |
| "uris": null, |
| "num": null, |
| "type_str": "figure" |
| }, |
| "FIGREF13": { |
| "text": "NPi is governed by t h e verb Va Because t h e r u l e of p r o j e c t i o n s holds i n JaFnese as i n o t h e r languages, a l l the noun phrases between NP c' + I and V are governed by V , and the noun phrases b e f o r e NP,: are governed by VA However, i n the cou.rse of a n a l y s i s , such boundaries cannot be determined uniquely. The analysis program fixes a temporary boundary and proceeds t o the next s t e p i n p r o c e s s i n g I f the temporary boundary i s not correct, the succeeding processing w i l l f a i l and the c o n t r o l w i l come back to t h e p o i n t a t which the temporary boundary was fixed. Now we w i l l show a simple example of structural a n a l y s i s by PLATON The example explains how the backtracking f a c i l i t y i s used i n analyzing Japanese sentences. Because we want t o v i s u a l i z e t h e operations of PLATON w i t h o u t b o t h e r i n g w i t h microscopic d e t a i l s of Japanese sentences, we w i l l take an imaginary problem as an example. The parser which is written in PLATON is described in another paper by M Nagao and J. T s u j i i (1976) An input s t r i n g is assumed to be a l i s t . The elements of t h e list are i n t e g e r s and trees are i n the form of ( X (SUM 0)). Here 'X' may b e regarded as a term modified by 'SUM 0' These two kinds of elements are arranged i n an arbitrary order, except that the last element i s the tree (X(SUM 0)). The following is an example of a n i n p u t s t r i n g : An Example String t o be Analyzed The result of the transformation i s expected to be i n the following fotm:This result is regarded as representing the following relationships between integers and 'X' .", |
| "uris": null, |
| "num": null, |
| "type_str": "figure" |
| }, |
| "FIGREF14": { |
| "text": "The number associated w i t h an 'X' by the relation 'SUM' shows the sum of the integers which are governed by the X . W e can look upon the relations r between integers and an X' as the r e l a t i o n s between noun phrases and the verb i n Japanese sentences. The r e s u l t of the analysis is assumed to satisfy the following conditions.", |
| "uris": null, |
| "num": null, |
| "type_str": "figure" |
| }, |
| "FIGREF15": { |
| "text": ": = ( (POPR /TEMP /REG) (SV :N (MINUS :N /TEMP)) ) end: = (NEXT BACKTRACK 01: : I /TEMP (X (SUM :N)) : J) )", |
| "uris": null, |
| "num": null, |
| "type_str": "figure" |
| }, |
| "FIGREF16": { |
| "text": "i s the! l i s t shown i n Figure 6. Since the start s t a t e is S W P , the f i r s t r u l e attached t o this s t a t e is a p p l i e d . T h i s r u l e w i l l find the l e f t m o s t 'x' and an integer just b e f o r e t h e 'x' (by SUMUP -I-, strx).", |
| "uris": null, |
| "num": null, |
| "type_str": "figure" |
| }, |
| "FIGREF17": { |
| "text": "n t h e < a c t > -p a r t , i s a PLATON f u n c t i o n which p u t s t h e second a r g u m e n t on the head of the f i r s t argument (SUMUP -I-, a c t ) After t h i s r u l e is a p p l i e d , t h e c o n t r o l will enter the s t a t e SUMUP again ( S W -I-, end).That is, t h i s rtile is a p p l i e d u n t i l there a r e no ~n t e g e r s before the f i r s t ' X' o r the sum of the i n t e g e r s . exceeds ten. A s the result, the environment i s the following: a t i o n s h i p temporarily fixed be tween i n t e g e r s and 'X' r u l e of SUMUP w i l l be a p p l i e d next. T h i s rule checks by its1 con> p a r t whether the r e s u l t a t hand s a t i s f i e s the t h i r d condition, t h a t i s , the c o n t e x t u a l r e s t r i c t i o n . Because t h e content of /RESULT is NIL, t h e function CONTEXTCHECK r e t u r n s the value T (SllMUl' -2-, con). So t h i s r u l e i s a p p l i c a b l e . Control makes t h e s t a t e -t r a n s i t i o n t o the s t a t e BACKTRACK (SUMUP -2-, end.) Because t h e first r u l e of BACKTRACK i s a NEXTBtype yule, s t a t e -s a v i n g is performed. That i s , tbe following environment i s saved: content of /REG = ( 2 1 3) c o n t e n t of /RESULT = NIL structure under processing = # 5 (X (SUM 6 ) ) 3 1 ( X (SUM 0 ) ) 2 2 (X (SUM 0 ) ) ) A t t h e final stage of t h e processing, t h e f o u r t h r u l e of S W a POP-type r u l e , i s a p p l i e d and r e t u r n s t h e value ( described a programming language c a l l e d PLATON f o r n a t u r a l language processing. The language has s e v e r a l a d d i t i o n a l capabilities beyond the ATN parser of W. Woods. Grammars written i n t h e language n o t only maintain c l a r i t y of representation but a l s o provide adequately a n a t u r a l i n t e r f a c e between the s y n t a c t i c component and o t h e r components. By means of t h e p a t t e r n -m a t c h i n g facility, w e can write grammars i n a quite n a t u r a l manner. And because of t h e PLATON v a r i a b l e b i n d i n g mechanism, semantic and c o n t e x t u a l LISP f u a c t i o n s a e a s i l y i n c o r p o r a t e d i n s y n t a c t i c patterns. F l e x i b l e b a c k t r a c k i n g mechanisms and push-down o p e r a t i o n s make com-, r, Acatecr n o n -d e t e r m i n i s t i c processing possible i n a very simple way. W e a r e now deveLoping an analysis program f o r Japanese using t h i s language. The program can accept f a i r l y complicated s e n t e n c e s i n a textbook of elementary chemistry It can u t i l i z e t h e lexical and contextual information of chemistry adequately during the analysis. Such i n f o r m a t i o n i n our system i s expressed i n the form of a semantic network s i m i l a r t o that of R. F. PLATON i t s e l f must be e q u i p p e d w i t h more semantics and context-oriented o p e r a t i o n s such as specified lexical d e s c r i p t i o n s and f u n c t i o n s u s i n g them. However, what d e s c r i p t i o n method i s most efficient, and moreover, what semantic information must be stored i n the lexicon, a r e not y e t entirely clear. So, as the f i r s t s t e p , PLATON leaves many p a r t s of t h e s e problems f o r", |
| "uris": null, |
| "num": null, |
| "type_str": "figure" |
| }, |
| "TABREF0": { |
| "content": "<table><tr><td>w</td><td/></tr><tr><td>Func t ion</td><td>Argument</td></tr><tr><td>SR</td><td>(regis ter-name> LISP -< form></td></tr><tr><td>SV</td><td>4 var i a b le-nam-LISP -4 form></td></tr><tr><td>GR</td><td>(regis ter-name></td></tr><tr><td>GV</td><td>(variab le-name></td></tr></table>", |
| "num": null, |
| "html": null, |
| "type_str": "table", |
| "text": "Functions of PLATON" |
| } |
| } |
| } |
| } |
