იხილეთ წყარო გვერდისთვის Pushdown Automata

{{ვიკიფიცირება}}
==Pushdown Automata==
კომპიუტერულ მეცნიერებებში  Pushdown Automata(PDA) არის მანქანის ისეთი ტიპი, რომელიც იყენებს [[სტეკს]]. PDA გამოიყენება ისეთ თეორიებში, რომელიც გვეუბნება რა შეიძლება დაითვალოს კომპიუტერული მანქანების მეშვეობით. ასეთი მანქანას აქვს მეტი შესაძლებლობები ვიდრე  სასრულ მდგომარეობიან მანქანას ([[finite automata]]), მაგრამ ნაკლები შეუძლია ვიდრე  [[ტურინგის მანქანას]].
იმის გამო რომ PDA-ში შემომავალი სტრინგი(Input) აღწერილია ფორმალური გრამატიკული ენით, ის შეიძლება გამოვიყენოთ  parser-ის დიზაინში. დეტერმინისტულ PDA-ს არ შეუძლია განმარტოს ყველა დეტერმინისტული [[context-free ენა]], მაშინ როდესაც არადეტერმინისტულ PDA-ს შეუძლია განმარტოს ყველა context-free ენა. სტეკის მქონე მანქანას შეუძლია გადაწყვიტოს ენათა უფრო დიდი სიმრავლე ვიდრე დეტერმინისტულ PDA-ს. ასევე, არსებობს ჩადგმულ სტეკიანი მანქანები ([[A nested stack automaton]]), რომელიც თავის თავში გულისხმობს უფრო კომპლექსურ მანქანას, კერძოდ ისეთს, რომელსაც სტეკში სასრული სიმბოლოების მაგივრად მნიშნელობებად აქვს ქვესტეკები.

ამ სტატიის დარჩენილ ნაწილში აღწერილია არადეტერმინისტული PDA.

==ოპერაცია==
[[Image:Pushdown-overview.svg|thumb|340px|Pushdown Automata-ს დიაგრამა]]
PDA-ს და სასრულ მდგომარეობიან მანქანას(finite state automata) აქვს ორი განმასხვავებელი ნიშანი:
1.	PDA-ს შეუძლია გამოიყენოს სტეკის პირველი ადგილი, რათა გადაწყვიტოს, რომელი გადაადგილება უნდა აიღოს.
2.	PDA-ს შეუძლია სტეკით მანიპულირება, გადაადგილების შესასრულებლად.
PDA-ს შეუძლია აირჩიოს გადაადგილება შემომავალი სტრინგის ინდექსირებით, არსებული მდგომარეობით და სტეკის თავში მყოფი სიმბოლოთი. ეს ნიშნავს, რომ ეს სამი პარამეტრი სრულად განსაზღვრავს გადაადგილებას, რომელიც არის არჩეული. სასრული მდგომარეობის მქონე მანქანას(finite state automata) უპირველეს ყოვლისა, უყურებს შემომავალ სტრინგს და ახლანდელ მდგომარეობას: მას არ აქვს სტეკი, რათა გამოიყენოს იგი. PDA-ს დამატებული აქვს სტეკი, როგორც პარამეტრი, რომელიც ეხმარება არჩევანის გაკეთებაში.
PDA-ს შეუძლია სტეკით მანიპულირება გადაადგილების შესასრულებლად. სასრული ფორმის მანქანა არჩევს ახალ მდგომარეობას მომდევნო გადაადგილების მეშვეობით. მანიპულაციის დროს მანქანას შეუძლია ამოიღოს კონკრეტული სიმბოლო, რომელიც იმყოფება სტეკის თავში. ასევე, ასეთ მანქანას შეუძლია დააიგნოროს და დატოვოს ისე როგორც არის. მანიპულაციის (ისევე როგორც სტეკის იგნორის) არჩევანი განსაზღვრულია გადაადგილების ცხრილით.

მოცემული შემომავალი სიგნალით, ახლანდელი მგომარეობითა და სტეკის სიმბოლოთი მანქანას შეუძლია გადავიდეს სხვა მდგომარეობაში და მანიპულაცია მოახდინოს სტეკზე (იღებს ან დებს სიმბოლოს). 
ზოგადად PDA-ს შეუძლია გააკეთოს სხვადასხვა გამოთვლები და მოქმედებები input-ზე. შედეგი არის დეტერმინისტული PDA და ენა ამ სიტყვების არის დეტერმინისტული  context-free ენა. თუმცა ყველა  context-free ენა არ არის დეტერმინისტული. ამ ყველაფრიდან გამომდინარეობს ის, რომ [[DPDA]] (Deterministic PDA)  არის უფრო სუსტი ვარიანტი PDA-ს. ასევე მნიშვნელოვანია ისიც, რომ არ არსებობს ალგორითმი, რომელიც მოცემულ PDA-ს გადაიყვანს ექვივალენტურ DPDA-ში(ცხადია, თუკი ასეთი DPDA არსებობს საერთოდ).
თუ ჩვენ დავუშვებთ იმას, რომ სასრულ მანქნას ჰქონდეს ორი სტეკი ერთის ნაცვლად, მივიღებთ გაუმჯობესებულ ვარიანტს, რომელიც ექვივალენტური იქნება ტურინგის მანქანის.

==დამოკიდებულება წინა მდგომარეობასთან (Backtracking)==
როგორც ზემოთ აღვნიშნეთ, არადეტერმინისტულ PDA-ს შეუძლია ერთ მოქმედებაზე მეტის გაკეთება როდესაც რამდენიმე ვარიანტი აქვს. სინამდვილეში ამისთვის საჭიროა, შეიქმნას ახალი მანქანა, რომელიც თავის მხრივ გადაწყვეტს სხვა არჩევანსაც. პრობლემა ის არის, რომ ასეთი მანქანები პრაქტიკაში ხშირად იჭრებიან. ასეთი შემთხვევების იდენტიფიცირება შეიძლება შემდეგნაირად: მანქანის აგების დროს, საჭიროა გამოვცადოთ (გავტესტოთ) ის გრამატიკა, რომელსაც მანქანა იყენებს. ეს შესაძლებლობას გვაძლევს ყველა ასეთ შემთხვევაში გამოვიყენოთ [[backtracking]], რათა გავაუმჯობესოდ წარმადობა.

==ფორმალური განსაზღვრება==
ჩვენ ვიყენებთ სტანდარტულ განსაზღვრებას:     რომელიც აღნიშნავს ანბანში  შემომავალ სტრინგებს, ხოლო    აღნიშნავს ცარიელ სტრინგს.
PDA განისაზღვრება 7 ნაწილისგან. ესენია:
<math>M=(Q,\  \Sigma,\  \Gamma,\  \delta, \ q_{0},\ Z, \ F)</math>

* <math>\, Q </math> არის სასრული სიმრავლე მდგომარეობებისა (states)
* <math>\,\Sigma</math> არის სასრული სიმრავლე, რომელსაც უწოდებენ შემომავალ ანბანი (input alphabet)
* <math>\,\Gamma</math> არის სასრული სიმრავლე, რომელსაც უწოდებენ სტეკის ანბანს (stack alphabet)
* <math>\,\delta</math> არის სასრული ქვესიმრავლე ~ ის, უწოდებენ (transition relation)
* <math>\,q_{0}\in\, Q </math> არის საწყისი მდგომარეობა (starting state)
* <math>\ Z\in\,\Gamma</math> სტეკის საწყისი სიმბოლო(initial stack symbol)
* <math>F\subseteq Q</math> მდგომარეობა, სადაც იღებს მანქანა სტრინგს (accepting states)
ყველა ელემენტი <math>(p,a,A,q,\alpha) \in \delta</math> არის <math>M</math>-ის გადასვლა. მას აქვს განსაზღვრული მნიშვნელობა რომ <math>M</math> მდგომარეობაში  <math>p \in Q</math> ,   <math>a \in \Sigma \cup\{\varepsilon\}</math> input-ით  , როგორც ყველაზე მნიშვნელოვანი სტეკის სიმბოლო, შესაძლოა წაიკითხოს  <math>a</math>, შეცვალოს მდგომარეობა <math>q</math>-დ, ამოიღოს <math>A</math>, ჩანაცვლებით  <math>\alpha \in \Gamma^*</math>.  <math>(\Sigma \cup\{\varepsilon\})</math>  გადანაცვლების კომპონენტი გამოიყენება იმის ფორმულირებისთვის, რომ PDA შეუძლია წაიკითხოს შემომავალი სტრინგიდან სიმბოლო, ან დატოვოს input ხელშეუხებელი.
ბევრ ტექსტში, გადასვლის დამოკიდებულება არის ჩანაცვლებული შემდეგი ექვივალენტური, ფორმალიზაციით:
* <math>\,\delta</math> არის გადასვლის ფუნქცია, შესაბამებით(mapping) <math>Q \times (\Sigma \cup\{\varepsilon\}) \times \Gamma</math> სასრული ქვესიმრავლე <math>Q \times \Gamma^*</math>  -ისა.

<math>\delta(p,a,A)</math>  შეიცავს ყველა შესაძლო ქმედებას<math>p</math> მდგომარეობაში და <math>A</math> სტეკის გამოყენებით, როდესაც კითხულობს  <math>a</math> -ს ინფუთად. ერთი წერს  <math>(q,\alpha) \in \delta(p,a,A)</math>  ზუსტად ფუნქციისთვის, როდესაც <math>(p,a,A,q,\alpha) \in\delta</math> შევნიშნოთ, რომ სასრული ამ შემთხვევაშ არის აუცილებელი.

==მაგალითი==
[[Image:Pda-example.svg|thumb|250px|PDA for <math>\{0^n1^n \mid n \ge 0\}</math> (by final state)]]
ეს არის ფორმალური განმარტება PDA-ს, რომელიც წყვეტს შემდეგ ენას:
<math>\{0^n1^n \mid n \ge 0 \}</math>

<math>M=(Q,\  \Sigma,\  \Gamma,\  \delta, \ p,\ Z, \ F)</math>, სადაც

<math>Q = \{ p,q,r \}</math>

<math>\Sigma = \{0, 1\}</math>

<math>\Gamma = \{A, Z\}</math>

<math>q_{0} = p</math>

<math>F = \{r\}</math>

<math>\delta</math> შედგები შემდეგი 6 ინსტრუქციისგან:

<math>(p,0,Z,p,AZ)</math>,
<math>(p,0,A,p,AA)</math>,
<math>(p,\epsilon,Z,q,Z)</math>,
<math>(p,\epsilon,A,q,A)</math>,
<math>(q,1,A,q,\epsilon)</math>, and
<math>(q,\epsilon,Z,r,Z)</math>.

სიტყვებით რომ ვთქვათ, <math>p</math> მდგომარეობაში ყოველი სიმბოლო <math>0</math>-თვის წავიკითხოთ და ჩავაგდოთ ერთი სიმბოლო  <math>A</math> სტეკში. <math>A</math>  -ს ჩაგდება სტეკის თავში ზემოდან კიდევ სხვა <math>A</math>-ზე, ფორმულირდება როგორც ამ ორის ჩანაცლება  <math>AA</math>-თი. <math>q</math> მდგომარეობაში ყოველი სიმბოლოსთვის, რომელიც არის <math>1</math>-იანი, წავიკითხოთ და ამოვაგდოთ  <math>A</math> სტეკიდან. ნებისმიერ მომენტში მანქანა შიძლება გადაადგილდეს <math>p</math>-დან <math>q</math> მდგომარეობაში. მაშინ როდესაც სტეკი შეიცავს ერთადერთ  სიმბოლოს <math>Z</math>-ს, მანქანას შეუძლია გადასვლა <math>q</math>-დან მიმღებ მდგომარეობაშ <math>r</math>(accepting state).

=='''გამოანგარიშების პროცესები'''==
[[Image:Pda-steps.svg|thumb|340px|მისაღები გამოთვლა <math>0011</math>-თვის]]
ქვემოთ აღწერილია, როგორ ხდება სხვადასხვა Input-ის გამოთვლა PDA-თი.
ა) შემავალი სტრინგი = 0011. გვაქვს გამოთვლის სხვადასხვა ვარიანტი, რომელიც დამოკიდებულია გადასვლაზე <math>p</math> მდგომარეობიდან <math>q</math> მდგომარეობაში. თუმცა, მხოლოდ ერთი იღებს ამ სტრინგს, ანუ არის მიმღები მდგომარეობა (accepting states).
: (i) <math>(p,0011,Z) \vdash (q,0011,Z) \vdash (r,0011,Z)</math> ფინალური მდგომარეობა იღებს, მაგრამ input ამ შემთხვევაში არ მიიღება, რადგან ის არ კითხულობს.
: (ii) <math>(p,0011,Z) \vdash (p,011,AZ) \vdash (q,011,AZ)</math> არ არის სხვა შესაძლო ვარიანტი.
: (iii) <math>(p,0011,Z) \vdash (p,011,AZ) \vdash (p,11,AAZ) \vdash (q,11,AAZ)</math> <math> \vdash (q,1,AZ) \vdash (q,\epsilon,Z)</math> <math> \vdash (r,\epsilon,Z)</math> მთავრდება მიმღებ მდგომარეობაში, როდესაც დასრულდება input-ის წაკითხვა.
ბ) შემომავალი სტრინგი = 00111. ასევე არის სხვადასხვა ვარიანტი გამოთვლის, თუმცა, არც ერთი არ იღებს შემომავალ სტრინგს
: (i) <math>(p,00111,Z) \vdash (q,00111,Z) \vdash (r,00111,Z)</math> საბოლოო მდგომარეობა იღებს, მაგრამ input არაა ბოლომდე წაკითხული
: (ii) <math>(p,00111,Z) \vdash (p,0111,AZ) \vdash (q,0111,AZ)</math> არ არის სხვა შესაძლო ვარიანტი
: (iii) <math>(p,00111,Z) \vdash (p,0111,AZ) \vdash (p,111,AAZ) \vdash (q,111,AAZ)</math> <math> \vdash (q,11,AZ) \vdash (q,1,Z)</math> <math> \vdash (r,1,Z)</math> მართალია, საბოლოო მდგომარეობა იღებს input-ს, მაგრამ ეს ის შემთხვევაა, როდესაც არ შეიძლება ვთქვათ, რომ input მიიღო, რადგან შემავალი სტრინგი არ არის  ბოლომდე წაკითხული.

=='''განზოგადებული PDA (GPDA)'''==
(GPDA) არის PDA, რომელიც წერს შემომავალი სტრინგის (ცნობილია სიგრძე) სტეკში და ასევე შლის მას სტეკიდან ერთ ბიჯზე.

(GPDA) განიმარტება შემდეგნაირად:

:<math>M=(Q,\  \Sigma,\  \Gamma,\  \delta, \ q_{0}, \ F)</math>
სადაც Q, <math>\Sigma\,</math>, <math>\Gamma\,</math>, q<sub>0</sub> არის განსაზღვრული როგორც PDA.
:<math>\,\delta</math>: <math>Q \times  \Sigma_{\epsilon}  \times \Gamma^{*} \longrightarrow P( Q \times \Gamma^{*} )</math>
არის ტრანზაციის ფუნქცია.
გამოთვლითი წესები GPDA-სთვის არის მსგავსად PDA-სი, განსხვავებით იმისა, რომ ai+1 და bi+1 არიან სტრინგები განსხვავებით სიმბოლოსი. GPDA  და  PDA არიამ ექვივალენტები, იმიტომ რომ თუ ენა გადაწყვეტადია PDA-თი, მაშინ ასევე ეს ენა გადაწყდება აუცილებლად GPDA-ითაც.
დავამტკიცოთ, რომ GPDA  და PDA არიან ექვივალენტურები:
ვთქვათ, <math>\delta</math>(q<sub>1</sub>, w, x<sub>1</sub>x<sub>2</sub>...x<sub>m</sub>) <math>\longrightarrow</math> (q<sub>2</sub>, y<sub>1</sub>y<sub>2</sub>...y<sub>n</sub> არის GPDA-ს გადასვლა, სადაც <math>q_1, q_2 \in Q</math>, <math>w \in\Sigma_{\epsilon}</math>, <math>x_1, x_2,\ldots,x_m\in\Gamma^{*}</math>, <math>m\geq0</math>, <math>y_1, y_2,\ldots,y_n\in\Gamma^{*}</math>, <math>n\geq 0</math>.

ავაგოთ შესაბამისი PDA:
::<math>\delta^{'}</math>(q<sub>1</sub>, w, x<sub>1</sub>) <math>\longrightarrow</math> (p<sub>1</sub>, <math>\epsilon</math>)

::<math>\delta^{'}</math>(p<sub>1</sub>, <math>\epsilon</math>, x<sub>2</sub>) <math>\longrightarrow</math> (p<sub>2</sub>, <math>\epsilon</math>)

::::<math>\vdots</math>

::<math>\delta^{'}</math>(p<sub>m-1</sub>, <math>\epsilon</math>, x<sub>m</sub>) <math>\longrightarrow</math> (p<sub>m</sub>, <math>\epsilon</math>)

::<math>\delta^{'}</math>(p<sub>m</sub>, <math>\epsilon</math>, <math>\epsilon</math> ) <math>\longrightarrow</math> (p<sub>m+1</sub>, y<sub>n</sub>)

::<math>\delta^{'}</math>(p<sub>m+1</sub>, <math>\epsilon</math>, <math>\epsilon</math> ) <math>\longrightarrow</math> (p<sub>m+2</sub>, y<sub>n-1</sub>)

::::<math>\vdots</math>

::<math>\delta^{'}</math>(p<sub>m+n-1</sub>, <math>\epsilon</math>, <math>\epsilon</math> ) <math>\longrightarrow</math> (q<sub>2</sub>, y<sub>1</sub>)