• Re: A simulating halt decider applied to the The Peter Linz Turing Mach

    From joes@21:1/5 to All on Sat Jun 1 18:52:09 2024
    XPost: sci.logic

    Am Sat, 01 Jun 2024 09:37:01 -0500 schrieb olcott:
    On 6/1/2024 2:52 AM, Mikko wrote:
    On 2024-05-31 15:35:18 +0000, olcott said:

    *A quick summary of the reasoning provided below*
    The LHS is behavior that embedded_H is allowed to report on.
    There is no restrictions on what embedded_H is allowed to report on.

    embedded_H is only allowed to report on the behavior that its finite
    string Turing Machine Description specifies to a UTM.

    embedded_H <is> a UTM except that it stops simulating and reports
    non-halting as soon as it correctly recognizes a non-halting behavior
    pattern that is specified by its input.
    "Except". So it is not an UTM.

    When Ĥ is applied to ⟨Ĥ⟩
    Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
    Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

    (a) Ĥ copies its input ⟨Ĥ⟩
    (b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
    (c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
    (d) simulated ⟨Ĥ⟩ copies its input ⟨Ĥ⟩
    (e) simulated ⟨Ĥ⟩ invokes simulated embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
    (f) simulated embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
    (g) goto (d)

    embedded_H is not allowed to be applied to Ĥ ⟨Ĥ⟩ because inputs can only be finite strings and Ĥ is not a finite string. This means
    that embedded_H is not allowed to report on its own actual behavior.
    I can't read that notation. What is H^ and what does it look like?

    embedded_H only allowed to report on the behavior specified by its
    finite string input. That behavior never stops running for 1 to ∞ steps
    of ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by embedded_H.

    The only reauirement is that embedded_H has the same transition
    rules as H. Therefore embedded_H reports the same as H, whether
    allowed or not.

    Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ derives a different result than embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩.

    This is because the in the latter case embedded_H must determine that ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly stop running
    after 1 to ∞ steps of correct simulation. Thus embedded_H meets its
    abort simulation criteria.

    The former case of Linz H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ can see that embedded_H
    has already aborted its simulation, thus it never reaches its own
    abort criteria.

    It is only because everyone since 1936 has rejected simulation
    OUT-OF-HAND without review that no one ever noticed this before.

    The RHS is behavior that embedded_H NOT is allowed to report on.
    The LHS and the RHS specify different behaviors.

    You have not shown anything with behaviours as LHS and RHS.

    Please to not reply here instead reply at the end of my proof
    after all of the steps have been presented.

    Not a reasonable request. Correctness of a step of proof does not
    depend on what follows. If one step is erroneous the rest is
    irrelevant.
    ^

    --
    joes

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From joes@21:1/5 to All on Mon Jun 3 20:01:09 2024
    Am Mon, 03 Jun 2024 14:00:04 -0500 schrieb olcott:
    On 6/3/2024 10:16 AM, Mikko wrote:
    On 2024-06-03 12:36:00 +0000, olcott said:
    On 6/3/2024 3:01 AM, Mikko wrote:
    On 2024-06-02 13:21:56 +0000, olcott said:
    On 6/2/2024 2:42 AM, Mikko wrote:
    On 2024-06-01 19:26:55 +0000, olcott said:
    On 6/1/2024 1:52 PM, joes wrote:
    Am Sat, 01 Jun 2024 09:37:01 -0500 schrieb olcott:
    On 6/1/2024 2:52 AM, Mikko wrote:
    On 2024-05-31 15:35:18 +0000, olcott said:

    I am so sure that I must be right that I do not notice any actual
    mistakes.
    FTFY.

    The only "mistake" that anyone ever pointed out is essentially "that's
    not the way that I memorized it".
    No, your mistake is the contradictory requirements for H:

    When the behavior of DD correctly simulated by HH is not the same as the behavior of the directly executed DD(DD)
    they assume the simulation must be wrong even though it it an easily
    verified fact that it is correct.
    That's not an assumption. That's the definition of simulation: doing
    exactly the same thing as the direct execution, which may be infinite recursion. But then H is not a decider.

    --
    joes

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)