Phỏng đoán về hai quầy automata

Tôi muốn chứng minh (hoặc bác bỏ) các phỏng đoán sau:

Phỏng đoán : hai bộ đếm automata (2CA) không thể quyết định ngôn ngữ sau:

$L = \{ n \mid$ các biểu diễn nhị phân và nhị phân của có cả độ dài chẵn hoặc độ dài lẻ$n$$\}$

2CA có thể dễ dàng kiểm tra xem biểu diễn nhị phân có độ dài chẵn hay lẻ (chỉ cần tiếp tục chia cho hai và cập nhật cờ "chiều dài chẵn" sau mỗi lần chia); theo cách tương tự, nó có thể kiểm tra xem đại diện ternary có độ dài chẵn hay lẻ (chỉ cần chia cho ba và cập nhật cờ "chẵn chiều dài" sau mỗi lần chia).

Nhưng để tính toán một trong số chúng, nó phải phá hủy đầu vào của nó và không thể khôi phục nó để tính toán cái còn lại; nên có vẻ như không có cách nào để quyết định .$L$

Bạn có biết một kỹ thuật có thể được sử dụng để chứng minh phỏng đoán?
Hoặc bạn có thể từ chối việc phỏng đoán xây dựng 2CA quyết định không? $L$

Tôi đã thử cách tiếp cận tương tự theo sau là Ibarra để chứng minh rằng 2CA không thể quyết định$\{n^2\mid n \geq 1\}$ , nhưng có vẻ như không đúng.

Lưu ý : để đơn giản, 2CA tương đương với một chương trình có một biến ban đầu chứa đầu vào và tập lệnh sau:$c$

• INC : thêm một vào biến;
• DEC : giảm (chỉ khi nó lớn hơn 0);$c$
• JZ $lab$ : nếu bằng không, hãy nhảy sang nhãn nếu không tiếp tục;l a $c$$lab$
• MUL$K$ : nhân với giá trị ;$c$$K$
• DIV$K [, lab_0, lab_1,...,lab_{K-1}]$ : chia cho hằng số và lưu thương số cho ( ); có thể nhảy đến các nhãn khác nhau theo phần còn lại ( );K c c = ⌊ c / K ⌋ c mod $c$$K$$c$$c = \lfloor c / K \rfloor$$c \bmod K$
• Phòng thí nghiệm GOTO$lab$ : nhảy vô điều kiện;
• HALT Chấp nhận | Từ chối : tạm dừng và chấp nhận hoặc tạm dừng và từ chối.

Ví dụ, một chương trình để kiểm tra xem biểu diễn nhị phân của $n$ có độ dài chẵn là:

   loop: JZ even   // test if n = 0
         DIV 2
         JZ odd    // test if n = 0
         DIV 2
         GOTO loop
   even: HALT Accept
    odd: HALT Reject

(chúng ta có thể xây dựng 2CA tương đương)

Vì vậy, mọi người cứ cằn nhằn tôi để đăng bài này mặc dù nó chỉ giải quyết được một phiên bản đơn giản hóa của vấn đề. Được thôi :)

Cuối cùng, tôi sẽ đưa một số điều tôi học được từ bài báo của Ibarra và Trân, và tại sao phương pháp đó phá vỡ vấn đề chung của chúng tôi, nhưng có lẽ vẫn cung cấp một số thông tin hữu ích.

Nhưng trước tiên, chúng ta sẽ xem xét vấn đề đơn giản hơn là cố gắng quyết định tập hợp

các ternary và cơ quan đại diện nhị phân của 2 n có cả chiều dài chẵn hoặc lẻ chiều dài$L = \{ 2^n \mid$$2^n$$\}$

Lưu ý làm thế nào điều này có chứ không phải n như trong vấn đề ban đầu. Cụ thể, nếu số đầu vào không phải là lũy thừa bằng 2, chúng tôi muốn từ chối nó thay vì cố gắng tính chiều dài của nó trong bất kỳ cơ sở nào.$2^n$$n$

Điều này giúp đơn giản hóa rất nhiều vấn đề: Nếu số gốc được viết là số nguyên tố là , sau đó với tất cả các v i ngoại trừ v 2, chúng ta chỉ cần kiểm tra xem tất cả chúng có phải là 0 không .$2^{v_2} 3^{v_3} 5^{v_5} 7^{v_7} ...$$v_i$$v_2$$0$

Điều này cho phép chúng ta giải quyết vấn đề đơn giản hóa này bằng cách sử dụng một trình bao bọc xung quanh phương thức cũ (theo Minsky tôi giả sử) để mã hóa trạng thái của một máy tự động -count theo số mũ của hệ số nguyên tố của một biến số tự động nhân / chia. mà như đã lưu ý trong OP ở trên là khá nhiều tương đương với một máy tự động 2 quầy.$k$

Đầu tiên, chúng ta cần một máy tự động -count để bọc. Chúng tôi sẽ sử dụng 3 quầy, đặt tên v 2 , v 3 và v 5 .$k$$v_2$$v_3$$v_5$

Máy tự động sẽ chấp nhận iff cho các giá trị bộ đếm ban đầu, các đại diện nhị phân và nhị phân của có cả chiều dài chẵn hoặc chiều dài lẻ và cả v 3 và v 5 đều bằng không. Khi nó chấp nhận nó trước tiên sẽ bằng không tất cả các quầy của nó.$2^{v_2}$$v_3$$v_5$

Đây là một số mã cho điều đó, trong một định dạng lắp ráp tương tự như OP (Tôi vừa thêm các biến vào hướng dẫn). Tôi chưa thực sự thử nghiệm nó, vì tôi không có gì để chạy nó, nhưng tôi coi đây là một hình thức: automata 3 bộ đếm nổi tiếng là Turing-Complete và có thể xây dựng bất kỳ chức năng tính toán nào của một trong số chúng giá trị ban đầu.

// Check that v3 and v5 are both zero.
                JZ v3, check5
                GOTO reject
check5:         JZ v5, init3
                GOTO reject
// Decrement v2 until it is zero, constructing 2^n in the process.  If 2^n
// was even, we will then pass to even2 with 2^n in v3; If 2^n was odd, we
// will pass to odd2 with 2^n in v5.
init3:          INC v3          // Set v3 to 1 = 2^0 to start with.
even1:          // We have decremented v2 an even number of times so far.
                // 2^decremented amount is in v3.
                JZ v2, odd2
                DEC v2
dup3to5:        JZ v3, odd1
                DEC v3
                INC v5
                INC v5
                GOTO dup3to5
odd1:           // We have decremented v2 an odd number of times so far.
                // 2^decremented amount is in v5.
                JZ v2, even2
                DEC v2
dup5to3:        JZ v5, even1
                DEC v5
                INC v3
                INC v3
                GOTO dup5to3
// The second part checks the ternary length of 2^n, which starts out in v3
// or v5 according to whether the *binary* length of 2^n (i.e. n+1) was odd
// or even.
odd2:           // v3 needs to have odd ternary length to accept.
                // It is simplest to consider 0 to have even length in both
                // binary and ternary.  This works out as long as we're
                // consistent.
                JZ v3, reject
trisect3to5:    DEC v3
                DEC v3
                JZ v3, even2
                DEC v3
                INC v5
                GOTO trisect3to5
even2:          // v5 needs to have even ternary length to accept
                JZ v5, accept
trisect5to3:    DEC v5
                DEC v5
                JZ v5, odd2
                DEC v5
                INC v3
                GOTO trisect5to3
accept:         HALT Accept
reject:         HALT Reject

Bước tiếp theo sau đó là mã hóa lại phần trên theo số mũ của một biến tự động. Vì kết quả khá dài, tôi sẽ chỉ mô tả phương pháp chung, nhưng một phiên bản đầy đủ (hơi "tối ưu hóa" tại chỗ) có trên trang web của tôi.

                JZ vp, label
                DEC vp
next:           ...

trở thành (về cơ bản chia cho p, và sau đó dọn dẹp để hoàn tác nếu phân chia không đồng đều):

                DIV p, next, ..., newlabel.fp-1
newlabel.f1:    MUL p
                GOTO newlabel.i1
...
newlabel.fp-1:  MUL p
                INC
newlabel.ip-2:  INC
...
newlabel.i1:    INC
                GOTO label
next:           ...

INC vptrở thành MUL p. Cá nhân JZvà DECđầu tiên có thể được thay đổi thành hình thức kết hợp. GOTO labelvà HALT Rejectkhông thay đổi.

HALT Acceptsẽ không thay đổi, ngoại trừ trong trường hợp của chúng tôi, chúng tôi vẫn có một kiểm tra cuối cùng để làm: chúng ta cần phải đảm bảo rằng không có thừa số nguyên tố trong số khác hơn 2,3 và 5. Kể từ đó số không automaton 3 toa của chúng tôi các quầy nó sử dụng khi nó chấp nhận, điều này rất đơn giản: chỉ cần kiểm tra biến cuối cùng là 1, có thể được thực hiện bằng cách nhảy tới mã

                DEC     // BTW it cannot be zero before this.
                JZ accept
                HALT Reject
accept:         HALT Accept

Mã trên trang web của tôi cũng có một kiểm tra ban đầu rằng số đó không bằng 0, mà tôi vừa nhận ra là dư thừa với các kiểm tra v3, v5 zero, ồ.

Như tôi đã đề cập, phương pháp trên hoạt động cho bài toán đơn giản, nhưng nó thực sự không có cơ hội làm việc cho bài toán chung, bởi vì: Trong bài toán chung, giá trị chính xác của mỗi số mũ của số nguyên tố để quyết định kích thước chung của nó và do đó kéo dài nó có trong các căn cứ khác nhau. Điều này có nghĩa rằng:

• Chúng tôi không có số nguyên tố "miễn phí" để sử dụng cho quầy.
• Thậm chí nếu chúng ta đã có số nguyên tố miễn phí cho quầy, chúng tôi không thực sự có một cách để trích xuất tất cả các thông tin cần thiết từ vô số số nguyên tố khác có giá trị số mũ làm vấn đề.

Vì vậy, hãy kết thúc bằng một lời giải thích về ý chính của phương pháp chung từ bài báo được liên kết ở trên của Ibarra và Trân ( phiên bản có thể tải xuống miễn phí ) để làm thế nào để chứng minh rằng một số vấn đề không thể giải quyết được bằng 2CA và cách nó bị phá vỡ một cách khó chịu trường hợp

$s$

Sau đó, họ phân tích máy tự động này để kết luận rằng họ có thể xây dựng các chuỗi số học nhất định của các số có hành vi được liên kết. Nói chính xác (Một số điều này không được nêu là định lý, nhưng được ẩn trong bằng chứng của cả hai ví dụ chính của chúng):

1. $v^x_i$$i$ $\leq s$$D>0$$x + n D$$n\geq 0$

2. $X$$s^2+1$$x\in X$$i$$v^x_i\leq s$$p, r\in X$$K_1,K_2$

   • $n\geq 0$$p + n K_1$$r + n K_2$

(Suy nghĩ:

• $x>s$$x\in X$
• Hầu hết những điều này cũng nên giữ cho các số bị từ chối , miễn là từ chối bằng cách tạm dừng rõ ràng thay vì hủy bỏ.)

$D,K_1,K_2$$>s$

$K_1 = K_2 = 6^k$$k$$p$$r$$2^k$$3^k$$p + 6^k n$$q + 6^k n$

$K_1\neq K_2$