एलआर पार्सिंग के साथ क्रमपरिवर्तन वाक्यांश

एक क्रमपरिवर्तन वाक्यांश मानक (ई) BNF संदर्भ मुक्त व्याकरण परिभाषाओं के लिए एक विस्तार है: एक क्रमचय वाक्यांश शामिल प्रस्तुतियों (या समतुल्य nonterminals) के माध्यम से । क्रमपरिवर्तन वाक्यांश की स्थिति में, हम इनमें से हर एक को ठीक एक बार देखना चाहेंगे, लेकिन हम इन अप्रतिष्ठानों के क्रम में रुचि नहीं रखते हैं। $\{ A_1, \dots, A_n \}$ $n$ $A_1$ $A_n$

उदाहरण के लिए:

S <- X { A, B, C } Y

के बराबर है:

S <- X  A B C  Y
S <- X  A C B  Y
S <- X  B A C  Y
S <- X  B C A  Y
S <- X  C A B  Y
S <- X  C B A  Y

इस अवधारणा को "प्रसंग वाक्यांशों के साथ संदर्भ-मुक्त व्याकरणों का विस्तार" में पेश किया गया लगता है । इसमें यह भी बताया गया है कि इन वाक्यांशों को एक एलएल (1) पार्सर का उपयोग करके रैखिक समय में कैसे पार किया जाए।

कागज "पार्सिंग क्रमचय वाक्यांश" पार्सर कॉम्बिनेटर का उपयोग करके क्रमपरिवर्तन वाक्यांशों को पार्स करने के लिए एक विधि का वर्णन करता है। ये केवल दो पेपर हैं जो मैंने पाया है कि क्रमपरिवर्तन वाक्यांशों और उन्हें पार्स करने के तरीके के बारे में बात करते हैं।

यह देखते हुए कि हम एलएल (1) आधारित पार्सर्स के साथ इन प्रकार के क्रमचय वाक्यांशों को आसानी से पार्स कर सकते हैं, मेरा अनुमान है कि हम एलआर (1) शैली पार्सर्स के साथ भी ऐसा कर सकते हैं। मेरा सवाल इसलिए है:

क्या यथोचित तालिका बनाए रखने के दौरान एलआर (1) मशीनरी का उपयोग करते हुए इनपुट स्ट्रिंग आकार में रैखिक व्याकरण युक्त वाक्यांशों को समय रेखीय में पार्स किया जा सकता है?

क्रमपरिवर्तन वाक्यांश संदर्भ-मुक्त भाषाओं की शक्ति का विस्तार नहीं करते हैं: जैसा कि ऊपर दिए गए मेरे उदाहरण में, बस सभी संभावित क्रमपरिवर्तन कर सकते हैं। हालाँकि, व्याकरण तब विस्फोट होता है क्योंकि परिणामस्वरूप व्याकरण आकार । यह रैखिक समय पार्सिंग की अनुमति देता है, लेकिन व्याकरण का आकार बहुत बड़ा हो जाता है। $O(|G|!)$

$O(2^{|G|})$

हालांकि यह बेहतर है, यह निश्चित रूप से अच्छा नहीं है - 30 वस्तुओं के क्रमचय वाक्यांश होने से व्याकरण अनुपयोगी हो जाएगा। एलआर पार्सिंग का एक हिस्सा अभी भी है जिसे हमने अभी तक नहीं छुआ है, और यह वास्तविक स्टैक-आधारित प्रक्रिया है जिसका उपयोग पार्सिंग के लिए किया जाता है। मैं कल्पना करता हूं कि स्टैक पर काउंटरों को जमा करना समस्या को हल करने में सक्षम हो सकता है, लेकिन मुझे यकीन नहीं है कि यह कैसे करना है।

मैं वर्तमान में एक पार्सर जनरेटर को लागू कर रहा हूं, और समस्या में डोमेन क्रमचय वाक्यांश स्वर्ग से एक उपहार होगा। जैसा कि मैं LR (1) मशीनरी का उपयोग कर रहा हूं, उपरोक्त प्रश्न का पालन किया गया है।

— एलेक्स दस कगार
स्रोत

LR (1) पार्सिंग की जटिलता व्याकरण वाक्यांशों के बिना व्याकरण के आकार में पहले से ही घातीय है --- सिवाय इसके अगर आप पार्सर की "मक्खी पर" गणना लागू करते हैं, लेकिन तब यह एक अर्ल पार्सर की तरह अधिक महसूस होता है वास्तविक LR (1) एक।

— सिल्वेन

आपके शेष प्रश्न के बारे में: cstheory.stackexchange.com/questions/4962/… क्रमपरिवर्तन के लिए CFG के आकार पर एक घातीय निचली सीमा दिखाता है, और पीडीए से CFG के सामान्य बहुपद निर्माण द्वारा, यह एक घातीय निम्न सीमा पर जोर देता है पीडीए का आकार भी।

— सिल्वेन

मैंने एलएल (1) के पेपर को नहीं देखा था। दरअसल, लागू किया गया पार्सर अब पीडीए नहीं है। मैं अभी भी "यथोचित आकार तालिका" के अस्तित्व में विश्वास नहीं करता हूं, क्योंकि कम्यूटेटिव संदर्भ-मुक्त व्याकरण के लिए सदस्यता एनपी-पूर्ण है (उदाहरण के लिए dx.doi.org/10.3233/FI-1997-3112 देखें ), लेकिन यह सच है हो सकता है कि कठिन वृत्तियाँ LR (1) न हों।

— सिल्वेन

@ सिल्वेन: क्या आप इस बारे में विस्तार से बता सकते हैं कि 4962 का संबंध किससे है? प्रश्न ४ ९ ६२ में, प्रत्येक इनपुट लंबाई के लिए क्रमपरिवर्तन निर्धारित किया गया है, और परिवर्तन की अनुमति दी जा रही है। वर्तमान प्रश्न में, हम क्रमपरिवर्तन को ठीक नहीं करते हैं। इसलिए मैं उनके बीच कोई वास्तविक संबंध देखने में विफल हूं।

— त्सुयोशी इतो

@Tsuyoshito Ito: LR (1) में इनपुट ग्रामर के बराबर DPDA पार्स करते हुए पहले निर्माण किया जाता है और फिर पहचानने के लिए स्ट्रिंग के खिलाफ चलाया जाता है। जैसा कि हर क्रमचय भाषा के लिए क्रमपरिवर्तन वाक्यांशों के साथ एक रैखिक आकार का CFG मौजूद है, युवल फिल्मस का पेपर (जो cstheory पर उनके उत्तर की तुलना में अधिक व्यापक है: cs.toronto.edu/~yuvalf/CGG-LB.pdf देखें ) कि नहीं ऐसे DPDA इनपुट व्याकरण के आकार में बहुपद आकार का हो सकता है।

— सिल्वेन

क्या आपने इसे शब्दार्थ समस्या में परिवर्तित करने पर विचार किया है? Nonterminals के सभी क्रमचय के लिए व्याकरण के नियमों के बजाय {A, B, C}, बस पहचानने का एक नियम है (A - B | C) ^ 3 विशेष आंतरिक कोड के साथ मिलकर सुनिश्चित करता है कि प्रत्येक में से केवल एक ही मान्यता प्राप्त है, अन्यथा एक त्रुटि। मैं उपरोक्त खंड से पहले एक खाली उत्पादन सम्मिलित करूंगा, जिसकी कमी ए, बी, और सी की गणना करने के लिए आप जो भी उपयोग कर रहे हैं उसका आरंभीकरण शुरू हो जाता है, और एक के बाद, जिसकी कमी काउंटर की जांच को ट्रिगर करती है और (यदि आवश्यक हो) त्रुटि का दावा करती है। (बेशक यह थोड़ा मुश्किल हो सकता है अगर व्याकरण ए, बी और / या सी के माध्यम से पुनरावर्ती है)

— PMar
स्रोत

मुझे नहीं लगता कि किसी को काउंटर की जरूरत है। अनिवार्य रूप से आप सिर्फ सभी क्रमपरिवर्तन की जांच करते हैं लेकिन तोड़ते हैं

छद्म कोड:

perm-match(input, pattern)
     if pattern = nil return true

     foreach(rule in pattern)
         if (match(input, rule))
             perm-match(input - matchedpart, pattern - rule)
             break
         end
     end
     return false
end

यहाँ एक और अधिक ठोस उदाहरण है

मान लीजिए हम abcd के किसी भी क्रमपरिवर्तन का मिलान करने की कोशिश कर रहे हैं और हमारी स्ट्रिंग bcda है

चरण 1: पहले मिलान किए गए प्रतीक का पता लगाएं। इस मामले में यह बी है
चरण 2: उस प्रतीक को हमारे पैटर्न से हटा दें और स्ट्रिंग को कम करें: उदाहरण के लिए, एसीडी और कोडा बचे हैं
चरण 3: नए तारों पर चरण 1 को दोहराएं
- c से c में मेल खाता है जो हमें विज्ञापन और दा के साथ छोड़ देता है
- दा में एक मैच जो हमें घ और घ के साथ छोड़ देता है
- d घ में मेल खाता है जो हमें दोनों तारों में नील के साथ छोड़ देता है

तो आप इस सरल एल्गोरिथ्म को क्रम से "स्ट्रिंग्स" की तुलना करके आसानी से क्रमचय की जांच कर सकते हैं। ध्यान दें कि फ़ंक्शन की जटिलता ओ (एन!) बदतर मामला है और ओ (1) सबसे अच्छा मामला है। एक अर्थ में हम एक सरणी में मिलान करने के लिए प्रतीकों को संग्रहीत करके गणना कर रहे हैं। मुझे लगता है कि यह सामान्य रूप से "तेज़" होगा क्योंकि अधिकांश मामलों में कोई बहुत बड़े एन के साथ सौदा नहीं करेगा।

— Uiy
स्रोत

n

$n$

n = 50

$n=50$