ต่ำกว่าผูกพันอยู่กับจำนวนของสาย oracle สำหรับการแก้กรณีของลังเลปัญหา

ฉันพบคำถามต่อไปนี้ซึ่งเป็นการออกกำลังกายอย่างง่าย (สปอยเลอร์ด้านล่าง)

เราจะได้รับกรณีของลังเลปัญหา (เช่นหน่วยความจำ ) และเราต้องตัดสินใจว่าที่ของพวกเขาหยุดใน\นั่นก็คือเราจะต้องมีการส่งออก\} เราได้รับ oracle สำหรับปัญหาการหยุดชะงัก แต่เราต้องใช้จำนวนครั้งน้อยที่สุด$n$$M_1,...,M_n$$\epsilon$$\{i: M_i\text{ halts on }\epsilon\}$

มันไม่ได้เป็นเรื่องยากที่จะแสดงให้เห็นว่ามันสามารถทำได้ด้วยโทร$\log (n+1)$

คำถามของฉันคือ: เราสามารถพิสูจน์ขอบเขตล่างได้หรือไม่? มีเหตุผลที่ต้องสงสัยไหมว่าข้อ จำกัด ดังกล่าวจะหายากมาก?

คำตอบสำหรับคำถามนั้นเอง (สปอยเลอร์, เม้าส์เลื่อน):

พิจารณากรณีของ TMs เราสามารถสร้าง TMที่รันในแบบคู่ขนานและหยุดถ้าอย่างน้อยสองคนหยุด (ไม่เช่นนั้นจะติดอยู่) ในทำนองเดียวกันเราสามารถสร้าง TMที่หยุดถ้าอย่างน้อยหนึ่งหยุด จากนั้นเราสามารถเรียก oracle บนH_2ถ้ามันหยุดแล้วเราสามารถเรียกใช้เครื่องจักรแบบขนานและรอให้เครื่องหยุด จากนั้นเราสามารถเรียก oracle บนอันสุดท้าย หาก oracle กล่าวว่า "ไม่" แล้วเราทำงาน oracle บนH_1ถ้ามันหยุดแล้วเราก็รันเครื่องจักรจนกว่าจะหยุดหนึ่งและมันก็จะหยุดเพียงครั้งเดียว หากไม่หยุดแสดงว่าไม่มีใครหยุดเลย การขยายไปยังเครื่องนั้นเป็นเรื่องง่าย$3$$H_2$$M_1,M_2,M_3$$H_1$$H_2$$H_1$$H_1$$n$

การสังเกตครั้งแรกเกี่ยวกับคำถามนี้ดูเหมือนว่าเป็นไปไม่ได้ที่จะแก้ไขโดยใช้เครื่องมือทางทฤษฎีข้อมูลเนื่องจากเราพึ่งพาความสามารถของเราในการรับข้อมูลโดยใช้เครื่องจักรโดยไม่มีการพยากรณ์

ผลลัพธ์สามารถพบได้ใน

• Beigel หม่อมราชวงศ์ Gasarch, WI, กิลล์เจและวิงส์เจ สั้น superterse และ verbose ชุด แจ้ง. และคำนวณ 103 (1993) หมายเลข 1, 68–85

หลักฐานของพวกเขาในความเป็นจริงแสดงให้เห็นว่าปัญหาของคุณไม่สามารถแก้ไขได้ด้วยการน้อยกว่าแบบสอบถามไปยังชุดใด ๆให้กับปัญหาการหยุดชะงักเพียงอย่างเดียว สำหรับสัญกรณ์บางครั้งปัญหาของคุณอาจแสดงเป็นหรือ (ขึ้นอยู่กับเครื่องหมายที่คุณชื่นชอบสำหรับปัญหาการหยุดชะงัก)$\log_2 n$$X$$C_n^K$$C_n^{HALT}$

สำหรับสิ่งนี้และผลลัพธ์ที่เกี่ยวข้องมากมายดูเพิ่มเติมที่:

• สำรวจโดย Gasarch นี้

• หนังสือเล่มนี้ถูกค้นพบในทฤษฎี Recursionโดย Gasarch และ Martin

แก้ไข: อาร์กิวเมนต์ที่ฉันตอบด้วยไม่ผิด แต่มันเป็นความเข้าใจผิดเล็กน้อยในที่มันแสดงให้เห็นว่าขอบเขตบนต้องแน่นสำหรับบาง (ซึ่งจริง ๆ เล็กน้อยเพราะต้องแน่นเมื่อและขอบเขตคือ 1)$n$$n=2$

นี่คือข้อโต้แย้งที่แม่นยำยิ่งขึ้น มันแสดงให้เห็นว่าถ้าผูกไว้บนของ หลวมสำหรับใด ๆแล้วสำหรับทุกจำนวนของสาย oracle ต้องเป็น(1)$\log_2 n$$n$ $n$$O(1)$

(แน่นอนว่าไม่ใช่ ดังนั้นขอบเขตสูงสุดไม่เคยหลวม! แต่ฉันไม่ได้พิสูจน์ที่นี่จริง ๆ และให้คำตอบอื่น ๆ สำหรับปัญหาดูเหมือนจะไม่คุ้มค่าเลย)$O(1)$

พิจารณาปัญหาของการคำนวณเอาต์พุตสูงสุด :

รับ -tupleของเครื่องจักรทัวริงคำนวณเอาท์พุทสูงสุด (ของเครื่องจักรทัวริงที่หยุดถ้าทำงานบน ) ถ้าไม่มีพวกเขาหยุดส่งคืน 0$n$$(M_1,\ldots,M_n)$$\epsilon$

ในฐานะที่เป็นฟังก์ชั่นของที่แย่ที่สุดของการเรียกใช้ oracle ที่ต้องใช้ในการคำนวณฟังก์ชั่นนี้จะเหมือนกับหมายเลขที่ต้องใช้ในการตัดสินใจว่าเครื่องใดที่หยุดรับ (ถ้าฉันรู้ว่าเครื่องหยุดฉันสามารถคำนวณผลลัพธ์สูงสุดได้อย่างง่ายดายในทางกลับกันถ้าฉันต้องการทราบว่าเครื่องหยุดทำงานใดหลังจากการก่อสร้างในคำแถลงปัญหาฉันสามารถสร้างเครื่อง ที่ทำงานทั้งหมดของเครื่องรับในแบบคู่ขนานแล้วหยุดและเอาท์พุถ้าของพวกเขาเคยหยุด. เอาท์พุทสูงสุดจะบอกฉันหมายเลขที่หยุด. จากที่ผมสามารถคำนวณ หยุดตรงไหน)$n$$n$$\{M'_i\}$ $(i=1,2,\ldots,n)$$M'_i$$n$$i$$i$

ทีนี้ปล่อยให้เป็นจำนวนเต็มที่น้อยที่สุด (ถ้ามี) ที่เก็บต่อไปนี้:$n_0$$n$

การใช้ oracle call เราสามารถคำนวณเอาท์พุทสูงสุดของเครื่องที่กำหนดได้ (นั่นคือขอบเขตบนไม่แน่นสำหรับ )$C(n) = \max\{k \in \mathbb{Z} : 2^k < n\}$$n$$n$

เห็นได้ชัดว่าเพราะ-1 ในความเป็นจริงแล้วด้วยเช่นกันเพราะแต่มันไม่สามารถตัดสินใจได้ว่าจะคำนวณเอาต์พุตสูงสุดของเครื่องที่กำหนด (โดยไม่มีการเรียกใช้ oracle) พิจารณาใหญ่กว่า:$n_0>1$$C(1) = -1$$n_0>2$$C(2) = 0$$2$$n$

การอ้างสิทธิ์: ถ้ามีค่า จำกัด ดังนั้นสำหรับใด ๆเราสามารถคำนวณเอาต์พุตสูงสุดของเครื่องที่ได้รับในการเรียก oracle$n_0$$n$$n$$C(n_0)$(โปรดทราบว่าหากมีค่า จำกัด ดังนั้น )$n_0$$C(n_0) = O(1)$

พิสูจน์ . เราพิสูจน์ได้โดยการเหนี่ยวนำบนnกรณีฐานมีที่ถือโดยความหมายของและC$n$$n\le n_0$$n_0$$C$

ให้เป็น TM ที่ได้รับเครื่องทัวริงใด ๆคำนวณเอาต์พุตสูงสุดโดยใช้การเรียกไปยัง oracle เท่านั้น$Q_0$$n_0$$C(n_0)$

แก้ไขใด ๆn>รับเครื่องจักรใดคำนวณผลลัพธ์สูงสุดดังนี้$n>n_0$$n$$M_1,\ldots, M_n$

มุ่งเน้นไปที่แรก เครื่อง ลองใช้งานกับเครื่องเหล่านี้โปรดทราบว่าทำให้การโทรไปยัง oracle และมีเพียงการตอบสนองที่เป็นไปได้โดย oracle ไปยังการเรียกเหล่านี้ โปรดทราบว่าโดยความหมาย<n_0 ให้แสดงการตอบสนองที่เป็นไปได้ของสำหรับแต่ละสร้างเครื่อง ที่จำลองบนเครื่องเหล่านี้ดังนี้:$M_1,\ldots,M_{n_0}$$Q_0$$n_0$$Q_0$$C(n_0)$$n' = 2^{C(n_0)}$$n' = 2^{C(n_0)} < n_0$$o_i$$i$$i=1,\ldots,n'$$M'_i$$Q_0$

TM (ที่อินพุต ):$M'_i$$\epsilon$

1. จำลองบนเครื่องแต่แทนที่จะเรียกพยากรณ์สมมติตอบสนอง oracle ตามo_i$Q_0$$n_0$$(M_1,\ldots,M_{n_0})$$o_i$
2. การจำลองนี้อาจไม่หยุดชะงัก (เช่นถ้าไม่ใช่สิ่งที่ Oracle จะกลับมาจริง)$o_i$
3. หากการจำลองหยุดลงให้เป็นเอาต์พุตสูงสุดที่บอกว่าจะได้รับ$h_i$$Q_0$
4. ประกบทุกเครื่อง{n_0}) หากหนึ่งในพวกเขาเคยเอาท์พุทหยุดและเอาท์พุทh_i$n_0$$(M_1,\ldots,M_{n_0})$$h_i$$h_i$

ตอนนี้ในลำดับที่กำหนดของเครื่องจักรแทนคนแรกเครื่องเหล่านี้เครื่อง'} ส่งกลับค่าคำนวณโดย recursing ในลำดับนี้เครื่อง (โปรดทราบว่า oracle ไม่ได้ถูกเรียกก่อนเรียกใช้ซ้ำดังนั้น oracle จะถูกเรียกใช้เมื่อถึงกรณีพื้นฐานเท่านั้น)$n$$n_0$$M_1,\ldots,M_{n_0}$$n'< n_0$$M'_1,\ldots,M'_{n'}$$n-(n_0-n') < n$

นี่คือเหตุผลที่การคำนวณนี้ถูกต้อง สำหรับเช่นนั้นคือการตอบสนองที่ถูกต้องโดย oracleสำหรับเคียวรีจะหยุดและให้เอาต์พุตสูงสุดที่ถูกต้องของเครื่องดั้งเดิม ดังนั้นการส่งออกสูงสุดของเครื่อง เป็นอย่างน้อยผลผลิตสูงสุดของเครื่อง{n_0}) บนมืออื่น ๆ โดยขั้นตอนที่ 4 ไม่มี สามารถให้ผลลัพธ์ที่มีขนาดใหญ่กว่าการส่งออกสูงสุดของ{n_0}) ดังนั้นการส่งออกสูงสุดของเครื่อง$i$$o_i$$Q_0$$M'_i$$n_0$$n'$$(M'_1,\ldots,M'_{n'})$$n_0$$(M_1,\ldots,M_{n_0})$$M'_i$$(M_1,\ldots,M_{n_0})$$n'$$(M'_1,\ldots,M'_{n'})$ เท่ากับเอาท์พุทสูงสุดของเครื่องที่พวกเขาแทนที่ QED$n_0$