मैं यह समझने की कोशिश कर रहा हूं कि "नियतात्मक संदर्भ-मुक्त व्याकरण" जैसे अभिव्यक्तियों में "नियतात्मक" का क्या अर्थ है। (इस क्षेत्र में अधिक निर्धारक "चीजें" हैं)। मैं एक उदाहरण की अधिक सराहना करता हूं फिर सबसे विस्तृत व्याख्या! अगर संभव हो तो।
भ्रम का मेरा प्राथमिक स्रोत यह बताने में सक्षम नहीं है कि एक व्याकरण की यह संपत्ति कैसे (गैर) अस्पष्टता से अलग है।
निकटतम मुझे यह खोजने के लिए मिला कि इसका अर्थ क्या है। यह कागज के डी। नथ द्वारा भाषाओं के अनुवाद पर बाएं से दाएं का उद्धरण है :
गिन्सबर्ग और ग्रीबाच (1965) ने एक नियतात्मक भाषा की धारणा को परिभाषित किया है; हम धारा V में दिखाते हैं कि ये ठीक वही भाषाएँ हैं जिनके लिए एक LR (k) व्याकरण मौजूद है
जो आपके पास आते ही सर्कुलर हो जाता है Section V
, क्योंकि वहां पर यह कहा जाता है कि LR (k) पार्सर क्या पार्स कर सकता है, जो नियतांक है ...
नीचे एक उदाहरण है जो मुझे यह समझने में मदद कर सकता है कि "अस्पष्ट" का अर्थ क्या है, कृपया एक नज़र डालें:
onewartwoearewe
जिसे one war two ear ewe
या के रूप में पार्स किया जा सकता है o new art woe are we
- यदि कोई व्याकरण अनुमति देता है (कहो कि यह मेरे द्वारा सूचीबद्ध सभी शब्द हैं)।
इस उदाहरण की भाषा (गैर-) निर्धारक बनाने के लिए मुझे क्या करने की आवश्यकता होगी? (मैं, उदाहरण के लिए, o
व्याकरण से शब्द को हटा सकता हूं, व्याकरण को अस्पष्ट नहीं बनाने के लिए)।
क्या उपरोक्त भाषा निर्धारक है?
पुनश्च। इसका उदाहरण गोडेल, एशर, बाख: अनन्त गोल्डन ब्रैड पुस्तक से है।
मान लीजिए, हम उदाहरण के लिए व्याकरण को इस तरह से परिभाषित करते हैं:
S -> A 'we' | A 'ewe'
A -> B | BA
B -> 'o' | 'new' | 'art' | 'woe' | 'are' | 'one' | 'war' | 'two' | 'ear'
संपूर्ण स्ट्रिंग को पार्स करने के तर्क से, क्या यह व्याकरण भाषा को गैर-निर्धारक नहीं बनाता है?
let explode s =
let rec exp i l =
if i < 0 then l else exp (i - 1) (s.[i] :: l) in
exp (String.length s - 1) [];;
let rec woe_parser s =
match s with
| 'w' :: 'e' :: [] -> true
| 'e' :: 'w' :: 'e' :: [] -> true
| 'o' :: x -> woe_parser x
| 'n' :: 'e' :: 'w' :: x -> woe_parser x
| 'a' :: 'r' :: 't' :: x -> woe_parser x
| 'w' :: 'o' :: 'e' :: x -> woe_parser x
| 'a' :: 'r' :: 'e' :: x -> woe_parser x
(* this line will trigger an error, because it creates
ambiguous grammar *)
| 'o' :: 'n' :: 'e' :: x -> woe_parser x
| 'w' :: 'a' :: 'r' :: x -> woe_parser x
| 't' :: 'w' :: 'o' :: x -> woe_parser x
| 'e' :: 'a' :: 'r' :: x -> woe_parser x
| _ -> false;;
woe_parser (explode "onewartwoearewe");;
- : bool = true
| Label | Pattern |
|---------+--------------|
| rule-01 | S -> A 'we' |
| rule-02 | S -> A 'ewe' |
| rule-03 | A -> B |
| rule-04 | A -> BA |
| rule-05 | B -> 'o' |
| rule-06 | B -> 'new' |
| rule-07 | B -> 'art' |
| rule-08 | B -> 'woe' |
| rule-09 | B -> 'are' |
| rule-10 | B -> 'one' |
| rule-11 | B -> 'war' |
| rule-12 | B -> 'two' |
| rule-13 | B -> 'ear' |
#+TBLFM: @2$1..@>$1='(format "rule-%02d" (1- @#));L
Generating =onewartwoearewe=
First way to generate:
| Input | Rule | Product |
|-------------------+---------+-------------------|
| '' | rule-01 | A'we' |
| A'we' | rule-04 | BA'we' |
| BA'we' | rule-05 | 'o'A'we' |
| 'o'A'we' | rule-04 | 'o'BA'we' |
| 'o'BA'we' | rule-06 | 'onew'A'we' |
| 'onew'A'we' | rule-04 | 'onew'BA'we' |
| 'onew'BA'we' | rule-07 | 'onewart'A'we' |
| 'onewart'A'we' | rule-04 | 'onewart'BA'we' |
| 'onewart'BA'we' | rule-08 | 'onewartwoe'A'we' |
| 'onewartwoe'A'we' | rule-03 | 'onewartwoe'B'we' |
| 'onewartwoe'B'we' | rule-09 | 'onewartwoearewe' |
|-------------------+---------+-------------------|
| | | 'onewartwoearewe' |
Second way to generate:
| Input | Rule | Product |
|-------------------+---------+-------------------|
| '' | rule-02 | A'ewe' |
| A'ewe' | rule-04 | BA'ewe' |
| BA'ewe' | rule-10 | 'one'A'ewe' |
| 'one'A'ewe' | rule-04 | 'one'BA'ewe' |
| 'one'BA'ewe' | rule-11 | 'onewar'A'ewe' |
| 'onewar'A'ewe' | rule-04 | 'onewar'BA'ewe' |
| 'onewar'BA'ewe' | rule-12 | 'onewartwo'A'ewe' |
| 'onewartwo'A'ewe' | rule-03 | 'onewartwo'B'ewe' |
| 'onewartwo'B'ewe' | rule-13 | 'onewartwoearewe' |
|-------------------+---------+-------------------|
| | | 'onewartwoearewe' |
B -> 'o'
, तो यह अब अस्पष्ट नहीं होगा ...
S
नियम से शुरू करें । नियम के अनुसार S := ...
, हम प्राप्त करते हैं ...
..."