วิธีแสดงรูปแบบการคำนวณสองแบบนั้นเทียบเท่ากันได้อย่างไร

ฉันกำลังหาคำอธิบายว่าจะพิสูจน์ได้อย่างไรว่าแบบจำลองการคำนวณสองแบบนั้นเทียบเท่ากัน ฉันอ่านหนังสือในเรื่องนี้แล้วยกเว้นการพิสูจน์ความเท่าเทียมกัน ฉันมีแนวคิดพื้นฐานเกี่ยวกับความหมายของการคำนวณทั้งสองรุ่นว่าเท่ากัน (มุมมองออโตมาตะ: หากพวกเขายอมรับภาษาเดียวกัน) มีวิธีอื่นในการคิดเกี่ยวกับความเท่าเทียมกันหรือไม่? หากคุณสามารถช่วยฉันเข้าใจวิธีการพิสูจน์ว่าโมเดลทัวริงของเครื่องจักรเทียบเท่ากับแคลคูลัสแลมบ์ดานั่นก็เพียงพอแล้ว

คุณแสดงให้เห็นว่าทั้งสองรุ่นสามารถจำลองอื่น ๆ ที่ได้รับเครื่องในรุ่น A แสดงให้เห็นว่ามีเครื่องในรุ่น B ที่คำนวณฟังก์ชั่นเดียวกัน โปรดทราบว่าการจำลองนี้ไม่จำเป็นต้องคำนวณ (แต่มักจะเป็น)

พิจารณาตัวอย่างเช่นกดลงออโตมาต้าพร้อมสองกอง (2-PDA) ในอีกคำถามหนึ่งการจำลองทั้งสองทิศทางนั้นได้อธิบายไว้ หากคุณทำสิ่งนี้อย่างเป็นทางการคุณจะต้องใช้เครื่องทัวริงทั่วไป (tuple) และสร้างสิ่งที่ 2-PDA ที่สอดคล้องกันอย่างชัดเจนและในทางกลับกัน

อย่างเป็นทางการการจำลองอาจมีลักษณะเช่นนี้ ปล่อย

$\qquad \displaystyle M = (Q,\Sigma_I,\Sigma_O,\delta,q_0,Q_F)$

เป็นเครื่องทัวริง (มีหนึ่งเทป) จากนั้น

$\qquad \displaystyle A_M = (Q \cup \{q^*_1,q^*_2\},\Sigma_I,\Sigma_O', \delta', q^*_1, Q_F)$

กับ$\Sigma_O' = \Sigma_O \overset{.}{\cup} \{\$\}$และ$\delta'$มอบให้โดย

$\quad \displaystyle (q^*_1,a,h_l,h_r) \to_{\delta'} (q^*_1,ah_l,h_r)$สำหรับทุก ∈ Σ ผมและเอชอาร์ , เอชลิตร ∈ Σ O ,$a \in \Sigma_I$$h_r,h_l \in \Sigma_O$
$\quad \displaystyle (q^*_1,\varepsilon,h_l,h_r) \to_{\delta'} (q^*_2,h_l,h_r)$สำหรับทุก$h_r,h_l \in \Sigma_O$ ,
$\quad \displaystyle (q^*_2,\varepsilon,h_l,h_r) \to_{\delta'} (q^*_2,\varepsilon,h_lh_r)$สำหรับทุก$h_r,h_l \in \Sigma_O$กับ$h_l \neq \$$ ,
$\quad \displaystyle (q^*_2,\varepsilon,\$,h_r) \to_{\delta'} (q_0,\$,h_r)$สำหรับทุก$h_r \in \Sigma_O$ ,
$\quad \displaystyle (q,\varepsilon,h_l,h_r) \to_{\delta'} (q',\varepsilon,h_la) \iff (q,h_r) \to_\delta (q',a,L)$สำหรับทุก$q \in Q$และ$h_l \in \Sigma_O$ ,
$\quad \displaystyle (q,\varepsilon,\$,h_r) \to_{\delta'} (q',\$,\square a) \iff (q,h_r) \to_\delta (q',a,L)$สำหรับทุก$q \in Q$ ,
$\quad \displaystyle (q,\varepsilon,h_l,h_r) \to_{\delta'} (q',ah_l,\varepsilon) \iff (q,h_r) \to_\delta (q',a,R)$ for all $q \in Q, h_l \in \Sigma_O'$,
$\quad \displaystyle (q,\varepsilon,h_l,\$) \to_{\delta'} (q,h_l,\square\$)$ for all $q \in Q$ and $h_l \in \Sigma_O'$, and
$\quad \displaystyle (q,\varepsilon,h_l,h_r) \to_{\delta'} (q',h_l,a) \iff (q,h_r) \to_\delta (q',a,N)$ for all $q \in Q,h_l\in\Sigma_O'$

$\square \in \Sigma_O$$\$\notin \Sigma_O$$(q,a,h_l,h_r) \to_{\delta'} (q',l_1\dots l_i,r_1\dots r_j)$ means that $A_M$ consumes input $a$, switches states from $q$ to $q'$ and updates the stacks like so:

^[source]

It remains to show that $A_M$ enters a final state on $x \in \Sigma_I^*$ if and only if $M$ does so. This is quite clear by construction; formally, you have to translate accepting runs on $M$ into accepting runs on $A_M$ and vice versa.

At the beginning of Communicating and Mobile Systems: the Pi-Calculus by Robin Milner, there is a introduction on automata and how they can simulate each other so that they cannot be distinguished : Bisimulation. (cf Bisimulation on wikipedia)

I don't remember well, I should re-read the chapter, but there was a trouble with simulation and bisimulation that made them not sufficient for computational equivalences.

Thus Robin Milner introduces his Pi-Calculus and exposes it for the rest of the book.

Ultimately, in his last book The Space and Motion of Communicating Agents, you could have a look at Robin Milner's Bigraphs. They can model Automata, Petri nets, Pi-Calculus and other computational methodologies.

As far as I know, the only (or at least most common) way to do this is to compare the languages the machines/models accept. That's the whole point of Automata theory: it takes the vague concept of a problem or algorithm and turns it into a concrete mathematical set (i.e. a language) which we can reason about.

The easiest way to do this is, given an arbitrary machine/function from one model, to construct a machine from the second model that computes the same language. Odds are you'll use induction in the length of the expression, states in the machine, rules in the grammar, etc.

I haven't seen this done with Lambda and TMs (though I'm 99% sure it's possible), but I have definitely seen this kind of thing for proving equivalence of NFAs and Regular expressions. First you show a NFA which can accept any atom, then using induction, you make NFAs which accept the union/concatenation/Kleene-star of any smaller NFAs.

Then you do the opposite, to find an RE for any NFA.