ভাষাটি
(যেখানে # 0 ( এক্স ) মধ্যে শূন্য সংখ্যা উল্লেখ করে এক্স )।
L×2={x⊥y⊥z∣x,y,z∈{0,1},#0(x)=#0(y) and |x|+|y|=z}
#0(x)x
এটা তোলে সিদ্ধান্ত নিতে সহজ মধ্যে শূন্য সংখ্যা: মান্য যে মেশিন চাহিদা দুই বৈশিষ্ট ট্র্যাক রাখতে - একটি করতো HAL মেশিন ব্যবহার এক্স বনাম Y এবং দৈর্ঘ্য এক্স , Y (বনাম z- র )। এটা একটা ধাক্কা পারেন যে শূন্য তাতে সূচিত জন্য গাদা মধ্যে এক্স (পরে এবং তারপর পপ কোনো শূন্য দেখা জন্য Y ); অতিরিক্তভাবে এটি x , y এর যেকোন বিটের জন্য ধাক্কা দেয় (এবং পরে z এর কোনও বিটের জন্য পপ হয় )। যেহেতু সমস্ত এসকে গাদা নীচে ঠেলাঠেলি করা হয়, তারা গণনাতে হস্তক্ষেপ করে না । ⊥L×2xyx,yz0
x0
y1
x,y1
z1
0
⊥ serves as a delimiter, and can be practically ignored.
Now, let L=LR×2, be the reverse language. That is,
L={z⊥y⊥x∣x,y,z∈{0,1},#0(x)=#0(y) and |x|+|y|=z}
We will show that no HAL machine can decide
L.
অনুভূতি নিম্নোক্ত। উপরে হিসাবে, মেশিনটি অবশ্যই এর দৈর্ঘ্য এবং x , y তে শূন্যের সংখ্যা উভয়ই ট্র্যাক করে রাখতে হবে । যাইহোক, এই ক্ষেত্রে এটি একই সাথে তাদের ট্র্যাক করা প্রয়োজন । এটি একটি গাদা মাধ্যমে করা যাবে না। আরও বিশদে, z পড়ার পরে , গাদা | এর দৈর্ঘ্য সম্পর্কে তথ্য অন্তর্ভুক্ত করে এক্স | + | y | । Y পড়ার সময় মেশিনটি অবশ্যই y এর শূন্যের সংখ্যাটি inেকে রাখতে হবে । তবে, আমরা এক্সের প্রত্যাশার দৈর্ঘ্যের উপরে ইতিমধ্যে হিপযুক্ত তথ্যটিতে এই তথ্য হস্তক্ষেপ করতে পারে নাzx,yz|x|+|y|yyxহতে। খুব স্বজ্ঞাতভাবে, হয় শূন্যের সংখ্যা সম্পর্কিত তথ্য এর দৈর্ঘ্য সম্পর্কে তথ্য "নীচে" হবে এবং তারপরে এক্স পড়ার সময় আমরা এটি অ্যাক্সেস করতে পারি না , বা এটি সেই তথ্য "উপরে" হয়, পরবর্তীটির অ্যাক্সেসযোগ্যকে রেন্ডারিং করে বা দুটি তথ্য "মিশ্রিত" হবে এবং অর্থহীন হয়ে উঠবে।xx
আরও আনুষ্ঠানিকভাবে, আমরা কিছু ধরণের "পাম্পিং" যুক্তি ব্যবহার করছি। এটি হ'ল আমরা একটি দীর্ঘ দীর্ঘ ইনপুট নেব এবং দেখাব যে মেশিনের "রাজ্য" অবশ্যই সেই ইনপুট প্রক্রিয়াকরণের সময় নিজেকে পুনরাবৃত্তি করতে পারে, যা মেশিন তার "রাষ্ট্র" পুনরাবৃত্তি করার পরে আমাদের ইনপুটটিকে "প্রতিস্থাপন" করতে দেয়।
আনুষ্ঠানিক প্রমাণের জন্য, আমাদের এইচএল মেশিনের কাঠামোর সরলীকরণ প্রয়োজন, যথা, এতে ট্রান্সশিশন 1 এর "লুপ" থাকে না । এই অনুমানের সাহায্যে আমরা দেখতে পাচ্ছি যে প্রতিটি ইনপুট প্রতীকের জন্য মেশিন প্রক্রিয়া করে, গাদাটির সামগ্রীটি বেশিরভাগ সি (কিছুটা বড় পর্যাপ্ত ধ্রুবক সি এর জন্য ) দ্বারা বৃদ্ধি বা হ্রাস করতে পারে ।ε1cc
প্রুফ।
ধরে নিন যে এল সিদ্ধান্ত নিয়েছে এবং একটি দীর্ঘ পর্যাপ্ত ইনপুট বিবেচনা করুন ( সুতরাং, দৈর্ঘ্যের 4 এন , সুতরাং | x | = | y | = n , | z | = 2 n , here গুলি এর পরে অগ্রাহ্য করবেন )। কংক্রিট হতে, z , y ঠিক করুন এবং ধরে নিন যে # 0 ( y ) = n / 2 । দেখুন যে সেখানে ( এনHL4n|x|=|y|=n|z|=2n⊥z,y#0(y)=n/2(nn/2) different x's such that z⊥y⊥x∈L.
Consider the heap's content immediately after processing z⊥y. It contains at most 3nc symbols (where each symbol is from a fixed alphabet Γ), by our assumption. However, there are (nn/2) different x′s that should be accepted (which is substantially larger than the amount of possible different contents for the heap, as this increases exponentially, while the different number of heaps increases polynomially, see below).
Take two inputs x1,x2 that should be accepted, so that the following holds:
- The prefix of length n/2 of x1 has different number of zeros than the prefix of x2 of the same length.
- By the time the machine reads a prefix of length n/2 of the x part, the heap looks the same for both x1 and x2, and also, the machine is in the same state (this must happen for some x1,x2, for large enough n, as there are more than 20.8n different options2 for x1,x2, and at most (3.5cn)|Γ||Q| different options for heap content and state3).
It is clear that the machine must accept the word z⊥y⊥xp1xs2, where xp1 is a prefix of x of length n/2 and xs2 is a suffix of x2 of the same length. Note that the number of zeros in xp1xs2 differs from the number of zeros in x1 and x2 (that is, from #0(y)), due to the way we chose x1 and x2, thus we reached a contradiction.
1 Does this assumption damages generality? I don't think so, but this indeed requires a proof. If someone sees how to get around this extra assumption, I'd love to know.
2 Let's fix x1 so that it's prefix (of length n/2 has exactly n/4 zeros). Recall that using Stirling's approximation we know that log(nk)≈nH(k/n) where H() is the Binary entropy funciton. Since H(1/4)≈0.81 we have (nn/4)>20.8n for large enough n.
3 Assuming alphabet Γ, there are |Γ|n different strings of length n, so if this was a stack we were screwed. However, pushing "01" into a heap is equivalent to pushing "10" - the heap stores only the sorted version of the content. The number of different sorted strings of size n is (n+1|Γ|−1)≈n|Γ|, for a constant |Γ|.