On 4/20/23 7:54 PM, olcott wrote:
> On 4/20/2023 6:14 PM, Richard Damon wrote:
>> On 4/20/23 6:51 PM, olcott wrote:
>>> On 4/20/2023 5:40 PM, Richard Damon wrote:
>>>> On 4/20/23 10:59 AM, olcott wrote:
>>>>> On 4/20/2023 7:06 AM, Richard Damon wrote:
>>>>>> On 4/20/23 7:56 AM, olcott wrote:
>>>>>>> On 4/20/2023 6:23 AM, Richard Damon wrote:
>>>>>>>> On 4/20/23 12:04 AM, olcott wrote:
>>>>>>>>> On 4/19/2023 10:41 PM, Richard Damon wrote:
>>>>>>>>>> On 4/19/23 11:29 PM, olcott wrote:
>>>>>>>>>>> On 4/19/2023 9:16 PM, Richard Damon wrote:
>>>>>>>>>>>> On 4/19/23 9:59 PM, olcott wrote:
>>>>>>>>>>>>> On 4/19/2023 8:38 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 4/19/23 9:25 PM, olcott wrote:
>>>>>>>>>>>>>>> On 4/19/2023 8:08 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 4/19/23 8:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 4/19/2023 7:45 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 4/19/23 8:31 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 4/19/2023 7:07 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 4/19/23 7:16 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 4/19/2023 5:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 4/19/23 11:05 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 4/19/2023 6:14 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 4/18/23 11:48 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> *You keep slip sliding with the fallacy of
>>>>>>>>>>>>>>>>>>>>>>>>> equivocation error*
>>>>>>>>>>>>>>>>>>>>>>>>> The actual simulated input: ⟨Ĥ⟩ that embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>> must compute its mapping
>>>>>>>>>>>>>>>>>>>>>>>>> from never reaches its simulated final state of
>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ.qn⟩ even after 10,000
>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct recursive simulations
>>>>>>>>>>>>>>>>>>>>>>>>> because ⟨Ĥ⟩ is defined to have
>>>>>>>>>>>>>>>>>>>>>>>>> a pathological relationship to embedded_H.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> An YOU keep on falling into your Strawman error.
>>>>>>>>>>>>>>>>>>>>>>>> The question is NOT what does the "simulation by
>>>>>>>>>>>>>>>>>>>>>>>> H" show, but what is the actual behavior of the
>>>>>>>>>>>>>>>>>>>>>>>> actual machine the input represents.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> When a simulating halt decider correctly
>>>>>>>>>>>>>>>>>>>>>>> simulates N steps of its input
>>>>>>>>>>>>>>>>>>>>>>> it derives the exact same N steps that a pure UTM
>>>>>>>>>>>>>>>>>>>>>>> would derive because
>>>>>>>>>>>>>>>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> No, it ISN'T a UTM because if fails to meeet the
>>>>>>>>>>>>>>>>>>>>>> definition of a UTM.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You are just proving that you are a pathological
>>>>>>>>>>>>>>>>>>>>>> liar that doesn't know what he is talking about.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> My reviewers cannot show that any of the extra
>>>>>>>>>>>>>>>>>>>>>>> features added to the UTM
>>>>>>>>>>>>>>>>>>>>>>> change the behavior of the simulated input for
>>>>>>>>>>>>>>>>>>>>>>> the first N steps of
>>>>>>>>>>>>>>>>>>>>>>> simulation:
>>>>>>>>>>>>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>>>>>>>>>>>>> (b) Matching non-halting behavior patterns
>>>>>>>>>>>>>>>>>>>>>>> doesn't change it
>>>>>>>>>>>>>>>>>>>>>>> (c) Even aborting the simulation after N steps
>>>>>>>>>>>>>>>>>>>>>>> doesn't change the first N steps.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Which don't matter, as the question
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The actual behavior that the actual input: ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>> represents is the
>>>>>>>>>>>>>>>>>>>>>>> behavior of the simulation of N steps by
>>>>>>>>>>>>>>>>>>>>>>> embedded_H because embedded_H
>>>>>>>>>>>>>>>>>>>>>>> has the exact same behavior as a UTM for these
>>>>>>>>>>>>>>>>>>>>>>> first N steps, and you
>>>>>>>>>>>>>>>>>>>>>>> already agreed with this.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> No, the actual behavior of the input is what the
>>>>>>>>>>>>>>>>>>>>>> MACHINE Ĥ applied to (Ĥ) does.
>>>>>>>>>>>>>>>>>>>>> Because embedded_H is a UTM that has been augmented
>>>>>>>>>>>>>>>>>>>>> with three features
>>>>>>>>>>>>>>>>>>>>> that cannot possibly cause its simulation of its
>>>>>>>>>>>>>>>>>>>>> input to diverge from
>>>>>>>>>>>>>>>>>>>>> the simulation of a pure UTM for the first N steps
>>>>>>>>>>>>>>>>>>>>> of simulation we know
>>>>>>>>>>>>>>>>>>>>> that it necessarily does provide the actual
>>>>>>>>>>>>>>>>>>>>> behavior specified by this
>>>>>>>>>>>>>>>>>>>>> input for these N steps.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> And is no longer a UTM, since if fails to meet the
>>>>>>>>>>>>>>>>>>>> requirement of a UTM
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> As you already agreed:
>>>>>>>>>>>>>>>>>>> The behavior of N steps of ⟨Ĥ⟩ simulated by
>>>>>>>>>>>>>>>>>>> embedded_H must are the actual behavior of these N
>>>>>>>>>>>>>>>>>>> steps because
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't
>>>>>>>>>>>>>>>>>>> change it
>>>>>>>>>>>>>>>>>>> (c) Even aborting the simulation after N steps
>>>>>>>>>>>>>>>>>>> doesn't change the
>>>>>>>>>>>>>>>>>>> first N steps.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> But a UTM doesn't simulate just "N" steps of its
>>>>>>>>>>>>>>>>>> input, but ALL of them.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Yet when embedded_H simulates N steps of ⟨Ĥ⟩ this is
>>>>>>>>>>>>>>>>> the actual behavior
>>>>>>>>>>>>>>>>> of ⟨Ĥ⟩ for these N steps, thus when embedded_H
>>>>>>>>>>>>>>>>> simulates 10,000
>>>>>>>>>>>>>>>>> recursive simulations these are the actual behavior of
>>>>>>>>>>>>>>>>> ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Yes, but doesn't actually show the ACTUAL behavior of
>>>>>>>>>>>>>>>> the input as defined,
>>>>>>>>>>>>>>> There is only one actual behavior of the actual input and
>>>>>>>>>>>>>>> this behavior
>>>>>>>>>>>>>>> is correctly demonstrated by N steps of ⟨Ĥ⟩ simulated by
>>>>>>>>>>>>>>> embedded_H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Nope, Read the problem definition.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The behavior to be decided by a Halt Decider is the
>>>>>>>>>>>>>> behavior of the ACTUAL MACHINE which is decribed by the
>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> No matter what the problem definition says the actual
>>>>>>>>>>>>> behavior of the
>>>>>>>>>>>>> actual input must necessarily be the N steps simulated by
>>>>>>>>>>>>> embedded_H.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The only alternative is to simply disbelieve in UTMs.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> NOPE, Since H isn't a UTM, because it doesn't meet the
>>>>>>>>>>>> REQUIREMENTS of a UTM, the statement is meaningless.
>>>>>>>>>>> It <is> equivalent to a UTM for the first N steps that can
>>>>>>>>>>> include 10,000 recursive simulations.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Which means it ISN'T the Equivalent of a UTM. PERIOD.
>>>>>>>>>
>>>>>>>>> Why are you playing head games with this?
>>>>>>>>>
>>>>>>>>> You know and acknowledged that the first N steps of ⟨Ĥ⟩ correctly
>>>>>>>>> simulated by embedded_H are the actual behavior of ⟨Ĥ⟩ for
>>>>>>>>> these first N
>>>>>>>>> steps.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Right, but we don't care about that. We care about the TOTAL
>>>>>>>> behavior of the input, which H never gets to see, because it
>>>>>>>> gives up.
>>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>
>>>>>>> N steps of ⟨Ĥ⟩ correctly simulated by embedded_H are the actual
>>>>>>> behavior of this input:
>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to embedded_H
>>>>>>> (b) embedded_H is applied to ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) which
>>>>>>> simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>> (c) *which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process*
>>>>>>
>>>>>> Until the outer embedded_H used by Ĥ reaches the point that it
>>>>>> decides to stop its simulation, and the whole simulation ends with
>>>>>> just partial results and it decides to go to qn and Ĥ Halts.
>>>>>>
>>>>>
>>>>> You keep dodging the key truth when N steps of embedded_H are
>>>>> correctly
>>>>> simulated by embedded_H and N = 30000 then we know that the actual
>>>>> behavior of ⟨Ĥ⟩ is 10,000 recursive simulations that have never
>>>>> reached
>>>>> their final state of ⟨Ĥ.qn⟩.
>>>>>
>>>>
>>>> No, it has been shown that if N = 3000, then
>>>
>>> the actual behavior of ⟨Ĥ⟩ is 10,000 recursive simulations that have
>>> never reached their final state of ⟨Ĥ.qn⟩ because ⟨Ĥ⟩ is defined to have
>>> a pathological relationship to embedded_H.
>>
>> No, becasue the ACTUAL BEHAVIOR is defined by the machine that the
>> input describes.
>>
>> PERIOD.
>>
>>>
>>> Referring to an entirely different sequence where there is no such
>>> pathological relationship is like comparing apples to lemons and
>>> rejecting apples because lemons are too sour.
>>
>> So, you just don't understand the meaning of ACTUAL BEHAVIOR
>>
>>>
>>> Why do you continue to believe that you can get away with this?
>>>
>>>
>>
>> Why do YOU?
>>
>> Can you name a reliable source that supports your definition? (NOT YOU)
>>
>
> Professor Sipser.
>

On 4/20/2023 6:14 PM, Richard Damon wrote:
> On 4/20/23 6:51 PM, olcott wrote:
>> On 4/20/2023 5:40 PM, Richard Damon wrote:
>>> On 4/20/23 10:59 AM, olcott wrote:
>>>> On 4/20/2023 7:06 AM, Richard Damon wrote:
>>>>> On 4/20/23 7:56 AM, olcott wrote:
>>>>>> On 4/20/2023 6:23 AM, Richard Damon wrote:
>>>>>>> On 4/20/23 12:04 AM, olcott wrote:
>>>>>>>> On 4/19/2023 10:41 PM, Richard Damon wrote:
>>>>>>>>> On 4/19/23 11:29 PM, olcott wrote:
>>>>>>>>>> On 4/19/2023 9:16 PM, Richard Damon wrote:
>>>>>>>>>>> On 4/19/23 9:59 PM, olcott wrote:
>>>>>>>>>>>> On 4/19/2023 8:38 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 4/19/23 9:25 PM, olcott wrote:
>>>>>>>>>>>>>> On 4/19/2023 8:08 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 4/19/23 8:52 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 4/19/2023 7:45 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 4/19/23 8:31 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 4/19/2023 7:07 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 4/19/23 7:16 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 4/19/2023 5:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 4/19/23 11:05 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 4/19/2023 6:14 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 4/18/23 11:48 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> *You keep slip sliding with the fallacy of
>>>>>>>>>>>>>>>>>>>>>>>> equivocation error*
>>>>>>>>>>>>>>>>>>>>>>>> The actual simulated input: ⟨Ĥ⟩ that embedded_H
>>>>>>>>>>>>>>>>>>>>>>>> must compute its mapping
>>>>>>>>>>>>>>>>>>>>>>>> from never reaches its simulated final state of
>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ.qn⟩ even after 10,000
>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct recursive simulations
>>>>>>>>>>>>>>>>>>>>>>>> because ⟨Ĥ⟩ is defined to have
>>>>>>>>>>>>>>>>>>>>>>>> a pathological relationship to embedded_H.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> An YOU keep on falling into your Strawman error.
>>>>>>>>>>>>>>>>>>>>>>> The question is NOT what does the "simulation by
>>>>>>>>>>>>>>>>>>>>>>> H" show, but what is the actual behavior of the
>>>>>>>>>>>>>>>>>>>>>>> actual machine the input represents.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> When a simulating halt decider correctly simulates
>>>>>>>>>>>>>>>>>>>>>> N steps of its input
>>>>>>>>>>>>>>>>>>>>>> it derives the exact same N steps that a pure UTM
>>>>>>>>>>>>>>>>>>>>>> would derive because
>>>>>>>>>>>>>>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> No, it ISN'T a UTM because if fails to meeet the
>>>>>>>>>>>>>>>>>>>>> definition of a UTM.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You are just proving that you are a pathological
>>>>>>>>>>>>>>>>>>>>> liar that doesn't know what he is talking about.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> My reviewers cannot show that any of the extra
>>>>>>>>>>>>>>>>>>>>>> features added to the UTM
>>>>>>>>>>>>>>>>>>>>>> change the behavior of the simulated input for the
>>>>>>>>>>>>>>>>>>>>>> first N steps of
>>>>>>>>>>>>>>>>>>>>>> simulation:
>>>>>>>>>>>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>>>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't
>>>>>>>>>>>>>>>>>>>>>> change it
>>>>>>>>>>>>>>>>>>>>>> (c) Even aborting the simulation after N steps
>>>>>>>>>>>>>>>>>>>>>> doesn't change the first N steps.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Which don't matter, as the question
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The actual behavior that the actual input: ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>> represents is the
>>>>>>>>>>>>>>>>>>>>>> behavior of the simulation of N steps by
>>>>>>>>>>>>>>>>>>>>>> embedded_H because embedded_H
>>>>>>>>>>>>>>>>>>>>>> has the exact same behavior as a UTM for these
>>>>>>>>>>>>>>>>>>>>>> first N steps, and you
>>>>>>>>>>>>>>>>>>>>>> already agreed with this.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> No, the actual behavior of the input is what the
>>>>>>>>>>>>>>>>>>>>> MACHINE Ĥ applied to (Ĥ) does.
>>>>>>>>>>>>>>>>>>>> Because embedded_H is a UTM that has been augmented
>>>>>>>>>>>>>>>>>>>> with three features
>>>>>>>>>>>>>>>>>>>> that cannot possibly cause its simulation of its
>>>>>>>>>>>>>>>>>>>> input to diverge from
>>>>>>>>>>>>>>>>>>>> the simulation of a pure UTM for the first N steps
>>>>>>>>>>>>>>>>>>>> of simulation we know
>>>>>>>>>>>>>>>>>>>> that it necessarily does provide the actual behavior
>>>>>>>>>>>>>>>>>>>> specified by this
>>>>>>>>>>>>>>>>>>>> input for these N steps.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> And is no longer a UTM, since if fails to meet the
>>>>>>>>>>>>>>>>>>> requirement of a UTM
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> As you already agreed:
>>>>>>>>>>>>>>>>>> The behavior of N steps of ⟨Ĥ⟩ simulated by embedded_H
>>>>>>>>>>>>>>>>>> must are the actual behavior of these N steps because
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't
>>>>>>>>>>>>>>>>>> change it
>>>>>>>>>>>>>>>>>> (c) Even aborting the simulation after N steps doesn't
>>>>>>>>>>>>>>>>>> change the
>>>>>>>>>>>>>>>>>> first N steps.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But a UTM doesn't simulate just "N" steps of its input,
>>>>>>>>>>>>>>>>> but ALL of them.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Yet when embedded_H simulates N steps of ⟨Ĥ⟩ this is the
>>>>>>>>>>>>>>>> actual behavior
>>>>>>>>>>>>>>>> of ⟨Ĥ⟩ for these N steps, thus when embedded_H simulates
>>>>>>>>>>>>>>>> 10,000
>>>>>>>>>>>>>>>> recursive simulations these are the actual behavior of ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Yes, but doesn't actually show the ACTUAL behavior of the
>>>>>>>>>>>>>>> input as defined,
>>>>>>>>>>>>>> There is only one actual behavior of the actual input and
>>>>>>>>>>>>>> this behavior
>>>>>>>>>>>>>> is correctly demonstrated by N steps of ⟨Ĥ⟩ simulated by
>>>>>>>>>>>>>> embedded_H.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope, Read the problem definition.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The behavior to be decided by a Halt Decider is the
>>>>>>>>>>>>> behavior of the ACTUAL MACHINE which is decribed by the input.
>>>>>>>>>>>>
>>>>>>>>>>>> No matter what the problem definition says the actual
>>>>>>>>>>>> behavior of the
>>>>>>>>>>>> actual input must necessarily be the N steps simulated by
>>>>>>>>>>>> embedded_H.
>>>>>>>>>>>>
>>>>>>>>>>>> The only alternative is to simply disbelieve in UTMs.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> NOPE, Since H isn't a UTM, because it doesn't meet the
>>>>>>>>>>> REQUIREMENTS of a UTM, the statement is meaningless.
>>>>>>>>>> It <is> equivalent to a UTM for the first N steps that can
>>>>>>>>>> include 10,000 recursive simulations.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Which means it ISN'T the Equivalent of a UTM. PERIOD.
>>>>>>>>
>>>>>>>> Why are you playing head games with this?
>>>>>>>>
>>>>>>>> You know and acknowledged that the first N steps of ⟨Ĥ⟩ correctly
>>>>>>>> simulated by embedded_H are the actual behavior of ⟨Ĥ⟩ for these
>>>>>>>> first N
>>>>>>>> steps.
>>>>>>>>
>>>>>>>
>>>>>>> Right, but we don't care about that. We care about the TOTAL
>>>>>>> behavior of the input, which H never gets to see, because it
>>>>>>> gives up.
>>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> N steps of ⟨Ĥ⟩ correctly simulated by embedded_H are the actual
>>>>>> behavior of this input:
>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to embedded_H
>>>>>> (b) embedded_H is applied to ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) which
>>>>>> simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>> (c) *which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process*
>>>>>
>>>>> Until the outer embedded_H used by Ĥ reaches the point that it
>>>>> decides to stop its simulation, and the whole simulation ends with
>>>>> just partial results and it decides to go to qn and Ĥ Halts.
>>>>>
>>>>
>>>> You keep dodging the key truth when N steps of embedded_H are correctly
>>>> simulated by embedded_H and N = 30000 then we know that the actual
>>>> behavior of ⟨Ĥ⟩ is 10,000 recursive simulations that have never reached
>>>> their final state of ⟨Ĥ.qn⟩.
>>>>
>>>
>>> No, it has been shown that if N = 3000, then
>>
>> the actual behavior of ⟨Ĥ⟩ is 10,000 recursive simulations that have
>> never reached their final state of ⟨Ĥ.qn⟩ because ⟨Ĥ⟩ is defined to have
>> a pathological relationship to embedded_H.
>
> No, becasue the ACTUAL BEHAVIOR is defined by the machine that the input
> describes.
>
> PERIOD.
>
>>
>> Referring to an entirely different sequence where there is no such
>> pathological relationship is like comparing apples to lemons and
>> rejecting apples because lemons are too sour.
>
> So, you just don't understand the meaning of ACTUAL BEHAVIOR
>
>>
>> Why do you continue to believe that you can get away with this?
>>
>>
>
> Why do YOU?
>
> Can you name a reliable source that supports your definition? (NOT YOU)
>
> Not just someone you have "tricked" into agreeing to a poorly worded
> statement that yo misinterpret to agree with you.
>

On 4/20/23 10:05 PM, olcott wrote:
> On 4/20/2023 6:14 PM, Richard Damon wrote:
>> On 4/20/23 6:51 PM, olcott wrote:
>>> On 4/20/2023 5:40 PM, Richard Damon wrote:
>>>> On 4/20/23 10:59 AM, olcott wrote:
>>>>> On 4/20/2023 7:06 AM, Richard Damon wrote:
>>>>>> On 4/20/23 7:56 AM, olcott wrote:
>>>>>>> On 4/20/2023 6:23 AM, Richard Damon wrote:
>>>>>>>> On 4/20/23 12:04 AM, olcott wrote:
>>>>>>>>> On 4/19/2023 10:41 PM, Richard Damon wrote:
>>>>>>>>>> On 4/19/23 11:29 PM, olcott wrote:
>>>>>>>>>>> On 4/19/2023 9:16 PM, Richard Damon wrote:
>>>>>>>>>>>> On 4/19/23 9:59 PM, olcott wrote:
>>>>>>>>>>>>> On 4/19/2023 8:38 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 4/19/23 9:25 PM, olcott wrote:
>>>>>>>>>>>>>>> On 4/19/2023 8:08 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 4/19/23 8:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 4/19/2023 7:45 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 4/19/23 8:31 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 4/19/2023 7:07 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 4/19/23 7:16 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 4/19/2023 5:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 4/19/23 11:05 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 4/19/2023 6:14 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 4/18/23 11:48 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> *You keep slip sliding with the fallacy of
>>>>>>>>>>>>>>>>>>>>>>>>> equivocation error*
>>>>>>>>>>>>>>>>>>>>>>>>> The actual simulated input: ⟨Ĥ⟩ that embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>> must compute its mapping
>>>>>>>>>>>>>>>>>>>>>>>>> from never reaches its simulated final state of
>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ.qn⟩ even after 10,000
>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct recursive simulations
>>>>>>>>>>>>>>>>>>>>>>>>> because ⟨Ĥ⟩ is defined to have
>>>>>>>>>>>>>>>>>>>>>>>>> a pathological relationship to embedded_H.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> An YOU keep on falling into your Strawman error.
>>>>>>>>>>>>>>>>>>>>>>>> The question is NOT what does the "simulation by
>>>>>>>>>>>>>>>>>>>>>>>> H" show, but what is the actual behavior of the
>>>>>>>>>>>>>>>>>>>>>>>> actual machine the input represents.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> When a simulating halt decider correctly
>>>>>>>>>>>>>>>>>>>>>>> simulates N steps of its input
>>>>>>>>>>>>>>>>>>>>>>> it derives the exact same N steps that a pure UTM
>>>>>>>>>>>>>>>>>>>>>>> would derive because
>>>>>>>>>>>>>>>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> No, it ISN'T a UTM because if fails to meeet the
>>>>>>>>>>>>>>>>>>>>>> definition of a UTM.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You are just proving that you are a pathological
>>>>>>>>>>>>>>>>>>>>>> liar that doesn't know what he is talking about.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> My reviewers cannot show that any of the extra
>>>>>>>>>>>>>>>>>>>>>>> features added to the UTM
>>>>>>>>>>>>>>>>>>>>>>> change the behavior of the simulated input for
>>>>>>>>>>>>>>>>>>>>>>> the first N steps of
>>>>>>>>>>>>>>>>>>>>>>> simulation:
>>>>>>>>>>>>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>>>>>>>>>>>>> (b) Matching non-halting behavior patterns
>>>>>>>>>>>>>>>>>>>>>>> doesn't change it
>>>>>>>>>>>>>>>>>>>>>>> (c) Even aborting the simulation after N steps
>>>>>>>>>>>>>>>>>>>>>>> doesn't change the first N steps.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Which don't matter, as the question
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The actual behavior that the actual input: ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>> represents is the
>>>>>>>>>>>>>>>>>>>>>>> behavior of the simulation of N steps by
>>>>>>>>>>>>>>>>>>>>>>> embedded_H because embedded_H
>>>>>>>>>>>>>>>>>>>>>>> has the exact same behavior as a UTM for these
>>>>>>>>>>>>>>>>>>>>>>> first N steps, and you
>>>>>>>>>>>>>>>>>>>>>>> already agreed with this.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> No, the actual behavior of the input is what the
>>>>>>>>>>>>>>>>>>>>>> MACHINE Ĥ applied to (Ĥ) does.
>>>>>>>>>>>>>>>>>>>>> Because embedded_H is a UTM that has been augmented
>>>>>>>>>>>>>>>>>>>>> with three features
>>>>>>>>>>>>>>>>>>>>> that cannot possibly cause its simulation of its
>>>>>>>>>>>>>>>>>>>>> input to diverge from
>>>>>>>>>>>>>>>>>>>>> the simulation of a pure UTM for the first N steps
>>>>>>>>>>>>>>>>>>>>> of simulation we know
>>>>>>>>>>>>>>>>>>>>> that it necessarily does provide the actual
>>>>>>>>>>>>>>>>>>>>> behavior specified by this
>>>>>>>>>>>>>>>>>>>>> input for these N steps.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> And is no longer a UTM, since if fails to meet the
>>>>>>>>>>>>>>>>>>>> requirement of a UTM
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> As you already agreed:
>>>>>>>>>>>>>>>>>>> The behavior of N steps of ⟨Ĥ⟩ simulated by
>>>>>>>>>>>>>>>>>>> embedded_H must are the actual behavior of these N
>>>>>>>>>>>>>>>>>>> steps because
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't
>>>>>>>>>>>>>>>>>>> change it
>>>>>>>>>>>>>>>>>>> (c) Even aborting the simulation after N steps
>>>>>>>>>>>>>>>>>>> doesn't change the
>>>>>>>>>>>>>>>>>>> first N steps.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> But a UTM doesn't simulate just "N" steps of its
>>>>>>>>>>>>>>>>>> input, but ALL of them.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Yet when embedded_H simulates N steps of ⟨Ĥ⟩ this is
>>>>>>>>>>>>>>>>> the actual behavior
>>>>>>>>>>>>>>>>> of ⟨Ĥ⟩ for these N steps, thus when embedded_H
>>>>>>>>>>>>>>>>> simulates 10,000
>>>>>>>>>>>>>>>>> recursive simulations these are the actual behavior of
>>>>>>>>>>>>>>>>> ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Yes, but doesn't actually show the ACTUAL behavior of
>>>>>>>>>>>>>>>> the input as defined,
>>>>>>>>>>>>>>> There is only one actual behavior of the actual input and
>>>>>>>>>>>>>>> this behavior
>>>>>>>>>>>>>>> is correctly demonstrated by N steps of ⟨Ĥ⟩ simulated by
>>>>>>>>>>>>>>> embedded_H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Nope, Read the problem definition.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The behavior to be decided by a Halt Decider is the
>>>>>>>>>>>>>> behavior of the ACTUAL MACHINE which is decribed by the
>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> No matter what the problem definition says the actual
>>>>>>>>>>>>> behavior of the
>>>>>>>>>>>>> actual input must necessarily be the N steps simulated by
>>>>>>>>>>>>> embedded_H.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The only alternative is to simply disbelieve in UTMs.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> NOPE, Since H isn't a UTM, because it doesn't meet the
>>>>>>>>>>>> REQUIREMENTS of a UTM, the statement is meaningless.
>>>>>>>>>>> It <is> equivalent to a UTM for the first N steps that can
>>>>>>>>>>> include 10,000 recursive simulations.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Which means it ISN'T the Equivalent of a UTM. PERIOD.
>>>>>>>>>
>>>>>>>>> Why are you playing head games with this?
>>>>>>>>>
>>>>>>>>> You know and acknowledged that the first N steps of ⟨Ĥ⟩ correctly
>>>>>>>>> simulated by embedded_H are the actual behavior of ⟨Ĥ⟩ for
>>>>>>>>> these first N
>>>>>>>>> steps.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Right, but we don't care about that. We care about the TOTAL
>>>>>>>> behavior of the input, which H never gets to see, because it
>>>>>>>> gives up.
>>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>
>>>>>>> N steps of ⟨Ĥ⟩ correctly simulated by embedded_H are the actual
>>>>>>> behavior of this input:
>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to embedded_H
>>>>>>> (b) embedded_H is applied to ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) which
>>>>>>> simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>> (c) *which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process*
>>>>>>
>>>>>> Until the outer embedded_H used by Ĥ reaches the point that it
>>>>>> decides to stop its simulation, and the whole simulation ends with
>>>>>> just partial results and it decides to go to qn and Ĥ Halts.
>>>>>>
>>>>>
>>>>> You keep dodging the key truth when N steps of embedded_H are
>>>>> correctly
>>>>> simulated by embedded_H and N = 30000 then we know that the actual
>>>>> behavior of ⟨Ĥ⟩ is 10,000 recursive simulations that have never
>>>>> reached
>>>>> their final state of ⟨Ĥ.qn⟩.
>>>>>
>>>>
>>>> No, it has been shown that if N = 3000, then
>>>
>>> the actual behavior of ⟨Ĥ⟩ is 10,000 recursive simulations that have
>>> never reached their final state of ⟨Ĥ.qn⟩ because ⟨Ĥ⟩ is defined to have
>>> a pathological relationship to embedded_H.
>>
>> No, becasue the ACTUAL BEHAVIOR is defined by the machine that the
>> input describes.
>>
>> PERIOD.
>>
>>>
>>> Referring to an entirely different sequence where there is no such
>>> pathological relationship is like comparing apples to lemons and
>>> rejecting apples because lemons are too sour.
>>
>> So, you just don't understand the meaning of ACTUAL BEHAVIOR
>>
>>>
>>> Why do you continue to believe that you can get away with this?
>>>
>>>
>>
>> Why do YOU?
>>
>> Can you name a reliable source that supports your definition? (NOT YOU)
>>
>> Not just someone you have "tricked" into agreeing to a poorly worded
>> statement that yo misinterpret to agree with you.
>>
>
> MIT Professor Michael Sipser has agreed that the following verbatim
> paragraph is correct:
>
> "If simulating halt decider H correctly simulates its input D until H
> correctly determines that its simulated D would never stop running
> unless aborted then H can abort its simulation of D and correctly report
> that D specifies a non-halting sequence of configurations."
>
> He understood that the above paragraph is a tautology. That you do not
> understand that it is a tautology provides zero evidence that it is not
> a tautology.
>
> You have already agreed that N steps of an input simulated by a
> simulating halt decider are the actual behavior for these N steps.
>
> The fact that you agreed with this seems to prove that you will not
> disagree with me at the expense of truth and that you do actually care
> about the truth.
>
>
>

On 4/20/2023 9:20 PM, Richard Damon wrote:
> On 4/20/23 10:05 PM, olcott wrote:
>> On 4/20/2023 6:14 PM, Richard Damon wrote:
>>> On 4/20/23 6:51 PM, olcott wrote:
>>>> On 4/20/2023 5:40 PM, Richard Damon wrote:
>>>>> On 4/20/23 10:59 AM, olcott wrote:
>>>>>> On 4/20/2023 7:06 AM, Richard Damon wrote:
>>>>>>> On 4/20/23 7:56 AM, olcott wrote:
>>>>>>>> On 4/20/2023 6:23 AM, Richard Damon wrote:
>>>>>>>>> On 4/20/23 12:04 AM, olcott wrote:
>>>>>>>>>> On 4/19/2023 10:41 PM, Richard Damon wrote:
>>>>>>>>>>> On 4/19/23 11:29 PM, olcott wrote:
>>>>>>>>>>>> On 4/19/2023 9:16 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 4/19/23 9:59 PM, olcott wrote:
>>>>>>>>>>>>>> On 4/19/2023 8:38 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 4/19/23 9:25 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 4/19/2023 8:08 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 4/19/23 8:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 4/19/2023 7:45 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 4/19/23 8:31 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 4/19/2023 7:07 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 4/19/23 7:16 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 4/19/2023 5:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 4/19/23 11:05 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 4/19/2023 6:14 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 4/18/23 11:48 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> *You keep slip sliding with the fallacy of
>>>>>>>>>>>>>>>>>>>>>>>>>> equivocation error*
>>>>>>>>>>>>>>>>>>>>>>>>>> The actual simulated input: ⟨Ĥ⟩ that
>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H must compute its mapping
>>>>>>>>>>>>>>>>>>>>>>>>>> from never reaches its simulated final state
>>>>>>>>>>>>>>>>>>>>>>>>>> of ⟨Ĥ.qn⟩ even after 10,000
>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct recursive simulations
>>>>>>>>>>>>>>>>>>>>>>>>>> because ⟨Ĥ⟩ is defined to have
>>>>>>>>>>>>>>>>>>>>>>>>>> a pathological relationship to embedded_H.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> An YOU keep on falling into your Strawman
>>>>>>>>>>>>>>>>>>>>>>>>> error. The question is NOT what does the
>>>>>>>>>>>>>>>>>>>>>>>>> "simulation by H" show, but what is the actual
>>>>>>>>>>>>>>>>>>>>>>>>> behavior of the actual machine the input
>>>>>>>>>>>>>>>>>>>>>>>>> represents.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> When a simulating halt decider correctly
>>>>>>>>>>>>>>>>>>>>>>>> simulates N steps of its input
>>>>>>>>>>>>>>>>>>>>>>>> it derives the exact same N steps that a pure
>>>>>>>>>>>>>>>>>>>>>>>> UTM would derive because
>>>>>>>>>>>>>>>>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> No, it ISN'T a UTM because if fails to meeet the
>>>>>>>>>>>>>>>>>>>>>>> definition of a UTM.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> You are just proving that you are a pathological
>>>>>>>>>>>>>>>>>>>>>>> liar that doesn't know what he is talking about.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> My reviewers cannot show that any of the extra
>>>>>>>>>>>>>>>>>>>>>>>> features added to the UTM
>>>>>>>>>>>>>>>>>>>>>>>> change the behavior of the simulated input for
>>>>>>>>>>>>>>>>>>>>>>>> the first N steps of
>>>>>>>>>>>>>>>>>>>>>>>> simulation:
>>>>>>>>>>>>>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>>>>>>>>>>>>>> (b) Matching non-halting behavior patterns
>>>>>>>>>>>>>>>>>>>>>>>> doesn't change it
>>>>>>>>>>>>>>>>>>>>>>>> (c) Even aborting the simulation after N steps
>>>>>>>>>>>>>>>>>>>>>>>> doesn't change the first N steps.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Which don't matter, as the question
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The actual behavior that the actual input: ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>> represents is the
>>>>>>>>>>>>>>>>>>>>>>>> behavior of the simulation of N steps by
>>>>>>>>>>>>>>>>>>>>>>>> embedded_H because embedded_H
>>>>>>>>>>>>>>>>>>>>>>>> has the exact same behavior as a UTM for these
>>>>>>>>>>>>>>>>>>>>>>>> first N steps, and you
>>>>>>>>>>>>>>>>>>>>>>>> already agreed with this.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> No, the actual behavior of the input is what the
>>>>>>>>>>>>>>>>>>>>>>> MACHINE Ĥ applied to (Ĥ) does.
>>>>>>>>>>>>>>>>>>>>>> Because embedded_H is a UTM that has been
>>>>>>>>>>>>>>>>>>>>>> augmented with three features
>>>>>>>>>>>>>>>>>>>>>> that cannot possibly cause its simulation of its
>>>>>>>>>>>>>>>>>>>>>> input to diverge from
>>>>>>>>>>>>>>>>>>>>>> the simulation of a pure UTM for the first N steps
>>>>>>>>>>>>>>>>>>>>>> of simulation we know
>>>>>>>>>>>>>>>>>>>>>> that it necessarily does provide the actual
>>>>>>>>>>>>>>>>>>>>>> behavior specified by this
>>>>>>>>>>>>>>>>>>>>>> input for these N steps.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> And is no longer a UTM, since if fails to meet the
>>>>>>>>>>>>>>>>>>>>> requirement of a UTM
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> As you already agreed:
>>>>>>>>>>>>>>>>>>>> The behavior of N steps of ⟨Ĥ⟩ simulated by
>>>>>>>>>>>>>>>>>>>> embedded_H must are the actual behavior of these N
>>>>>>>>>>>>>>>>>>>> steps because
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't
>>>>>>>>>>>>>>>>>>>> change it
>>>>>>>>>>>>>>>>>>>> (c) Even aborting the simulation after N steps
>>>>>>>>>>>>>>>>>>>> doesn't change the
>>>>>>>>>>>>>>>>>>>> first N steps.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> But a UTM doesn't simulate just "N" steps of its
>>>>>>>>>>>>>>>>>>> input, but ALL of them.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Yet when embedded_H simulates N steps of ⟨Ĥ⟩ this is
>>>>>>>>>>>>>>>>>> the actual behavior
>>>>>>>>>>>>>>>>>> of ⟨Ĥ⟩ for these N steps, thus when embedded_H
>>>>>>>>>>>>>>>>>> simulates 10,000
>>>>>>>>>>>>>>>>>> recursive simulations these are the actual behavior of
>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Yes, but doesn't actually show the ACTUAL behavior of
>>>>>>>>>>>>>>>>> the input as defined,
>>>>>>>>>>>>>>>> There is only one actual behavior of the actual input
>>>>>>>>>>>>>>>> and this behavior
>>>>>>>>>>>>>>>> is correctly demonstrated by N steps of ⟨Ĥ⟩ simulated by
>>>>>>>>>>>>>>>> embedded_H.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Nope, Read the problem definition.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The behavior to be decided by a Halt Decider is the
>>>>>>>>>>>>>>> behavior of the ACTUAL MACHINE which is decribed by the
>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No matter what the problem definition says the actual
>>>>>>>>>>>>>> behavior of the
>>>>>>>>>>>>>> actual input must necessarily be the N steps simulated by
>>>>>>>>>>>>>> embedded_H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The only alternative is to simply disbelieve in UTMs.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> NOPE, Since H isn't a UTM, because it doesn't meet the
>>>>>>>>>>>>> REQUIREMENTS of a UTM, the statement is meaningless.
>>>>>>>>>>>> It <is> equivalent to a UTM for the first N steps that can
>>>>>>>>>>>> include 10,000 recursive simulations.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Which means it ISN'T the Equivalent of a UTM. PERIOD.
>>>>>>>>>>
>>>>>>>>>> Why are you playing head games with this?
>>>>>>>>>>
>>>>>>>>>> You know and acknowledged that the first N steps of ⟨Ĥ⟩ correctly
>>>>>>>>>> simulated by embedded_H are the actual behavior of ⟨Ĥ⟩ for
>>>>>>>>>> these first N
>>>>>>>>>> steps.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Right, but we don't care about that. We care about the TOTAL
>>>>>>>>> behavior of the input, which H never gets to see, because it
>>>>>>>>> gives up.
>>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>
>>>>>>>> N steps of ⟨Ĥ⟩ correctly simulated by embedded_H are the actual
>>>>>>>> behavior of this input:
>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to embedded_H
>>>>>>>> (b) embedded_H is applied to ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) which
>>>>>>>> simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>> (c) *which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the
>>>>>>>> process*
>>>>>>>
>>>>>>> Until the outer embedded_H used by Ĥ reaches the point that it
>>>>>>> decides to stop its simulation, and the whole simulation ends
>>>>>>> with just partial results and it decides to go to qn and Ĥ Halts.
>>>>>>>
>>>>>>
>>>>>> You keep dodging the key truth when N steps of embedded_H are
>>>>>> correctly
>>>>>> simulated by embedded_H and N = 30000 then we know that the actual
>>>>>> behavior of ⟨Ĥ⟩ is 10,000 recursive simulations that have never
>>>>>> reached
>>>>>> their final state of ⟨Ĥ.qn⟩.
>>>>>>
>>>>>
>>>>> No, it has been shown that if N = 3000, then
>>>>
>>>> the actual behavior of ⟨Ĥ⟩ is 10,000 recursive simulations that have
>>>> never reached their final state of ⟨Ĥ.qn⟩ because ⟨Ĥ⟩ is defined to
>>>> have
>>>> a pathological relationship to embedded_H.
>>>
>>> No, becasue the ACTUAL BEHAVIOR is defined by the machine that the
>>> input describes.
>>>
>>> PERIOD.
>>>
>>>>
>>>> Referring to an entirely different sequence where there is no such
>>>> pathological relationship is like comparing apples to lemons and
>>>> rejecting apples because lemons are too sour.
>>>
>>> So, you just don't understand the meaning of ACTUAL BEHAVIOR
>>>
>>>>
>>>> Why do you continue to believe that you can get away with this?
>>>>
>>>>
>>>
>>> Why do YOU?
>>>
>>> Can you name a reliable source that supports your definition? (NOT YOU)
>>>
>>> Not just someone you have "tricked" into agreeing to a poorly worded
>>> statement that yo misinterpret to agree with you.
>>>
>>
>> MIT Professor Michael Sipser has agreed that the following verbatim
>> paragraph is correct:
>>
>> "If simulating halt decider H correctly simulates its input D until H
>> correctly determines that its simulated D would never stop running
>> unless aborted then H can abort its simulation of D and correctly report
>> that D specifies a non-halting sequence of configurations."
>>
>> He understood that the above paragraph is a tautology. That you do not
>> understand that it is a tautology provides zero evidence that it is not
>> a tautology.
>>
>> You have already agreed that N steps of an input simulated by a
>> simulating halt decider are the actual behavior for these N steps.
>>
>> The fact that you agreed with this seems to prove that you will not
>> disagree with me at the expense of truth and that you do actually care
>> about the truth.
>>
>>
>>
>
> Right, like I said, *IF* the decider correctly simulates its input D
> until H *CORRECTLY* determines that its Simulate D would never stop
> running unless aborted.
>
> NOTE. THAT MEANS THE ACTUAL MACHIBE OR A UTM SIMULATION OF THE MACHINE.
> NOT JUST A PARTIAL SIMULATION BY H.
>
Unless the simulation is from the frame-of-reference of the pathological
relationship it is rejecting apples because lemons are too sour.

On 4/20/23 10:43 PM, olcott wrote:
> On 4/20/2023 9:20 PM, Richard Damon wrote:
>> On 4/20/23 10:05 PM, olcott wrote:
>>> On 4/20/2023 6:14 PM, Richard Damon wrote:
>>>> On 4/20/23 6:51 PM, olcott wrote:
>>>>> On 4/20/2023 5:40 PM, Richard Damon wrote:
>>>>>> On 4/20/23 10:59 AM, olcott wrote:
>>>>>>> On 4/20/2023 7:06 AM, Richard Damon wrote:
>>>>>>>> On 4/20/23 7:56 AM, olcott wrote:
>>>>>>>>> On 4/20/2023 6:23 AM, Richard Damon wrote:
>>>>>>>>>> On 4/20/23 12:04 AM, olcott wrote:
>>>>>>>>>>> On 4/19/2023 10:41 PM, Richard Damon wrote:
>>>>>>>>>>>> On 4/19/23 11:29 PM, olcott wrote:
>>>>>>>>>>>>> On 4/19/2023 9:16 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 4/19/23 9:59 PM, olcott wrote:
>>>>>>>>>>>>>>> On 4/19/2023 8:38 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 4/19/23 9:25 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 4/19/2023 8:08 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 4/19/23 8:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 4/19/2023 7:45 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 4/19/23 8:31 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 4/19/2023 7:07 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 4/19/23 7:16 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 4/19/2023 5:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 4/19/23 11:05 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 4/19/2023 6:14 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/18/23 11:48 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> *You keep slip sliding with the fallacy of
>>>>>>>>>>>>>>>>>>>>>>>>>>> equivocation error*
>>>>>>>>>>>>>>>>>>>>>>>>>>> The actual simulated input: ⟨Ĥ⟩ that
>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H must compute its mapping
>>>>>>>>>>>>>>>>>>>>>>>>>>> from never reaches its simulated final state
>>>>>>>>>>>>>>>>>>>>>>>>>>> of ⟨Ĥ.qn⟩ even after 10,000
>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct recursive simulations
>>>>>>>>>>>>>>>>>>>>>>>>>>> because ⟨Ĥ⟩ is defined to have
>>>>>>>>>>>>>>>>>>>>>>>>>>> a pathological relationship to embedded_H.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> An YOU keep on falling into your Strawman
>>>>>>>>>>>>>>>>>>>>>>>>>> error. The question is NOT what does the
>>>>>>>>>>>>>>>>>>>>>>>>>> "simulation by H" show, but what is the actual
>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of the actual machine the input
>>>>>>>>>>>>>>>>>>>>>>>>>> represents.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> When a simulating halt decider correctly
>>>>>>>>>>>>>>>>>>>>>>>>> simulates N steps of its input
>>>>>>>>>>>>>>>>>>>>>>>>> it derives the exact same N steps that a pure
>>>>>>>>>>>>>>>>>>>>>>>>> UTM would derive because
>>>>>>>>>>>>>>>>>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> No, it ISN'T a UTM because if fails to meeet the
>>>>>>>>>>>>>>>>>>>>>>>> definition of a UTM.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> You are just proving that you are a pathological
>>>>>>>>>>>>>>>>>>>>>>>> liar that doesn't know what he is talking about.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> My reviewers cannot show that any of the extra
>>>>>>>>>>>>>>>>>>>>>>>>> features added to the UTM
>>>>>>>>>>>>>>>>>>>>>>>>> change the behavior of the simulated input for
>>>>>>>>>>>>>>>>>>>>>>>>> the first N steps of
>>>>>>>>>>>>>>>>>>>>>>>>> simulation:
>>>>>>>>>>>>>>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>>>>>>>>>>>>>>> (b) Matching non-halting behavior patterns
>>>>>>>>>>>>>>>>>>>>>>>>> doesn't change it
>>>>>>>>>>>>>>>>>>>>>>>>> (c) Even aborting the simulation after N steps
>>>>>>>>>>>>>>>>>>>>>>>>> doesn't change the first N steps.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Which don't matter, as the question
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The actual behavior that the actual input: ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>> represents is the
>>>>>>>>>>>>>>>>>>>>>>>>> behavior of the simulation of N steps by
>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H because embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>> has the exact same behavior as a UTM for these
>>>>>>>>>>>>>>>>>>>>>>>>> first N steps, and you
>>>>>>>>>>>>>>>>>>>>>>>>> already agreed with this.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> No, the actual behavior of the input is what the
>>>>>>>>>>>>>>>>>>>>>>>> MACHINE Ĥ applied to (Ĥ) does.
>>>>>>>>>>>>>>>>>>>>>>> Because embedded_H is a UTM that has been
>>>>>>>>>>>>>>>>>>>>>>> augmented with three features
>>>>>>>>>>>>>>>>>>>>>>> that cannot possibly cause its simulation of its
>>>>>>>>>>>>>>>>>>>>>>> input to diverge from
>>>>>>>>>>>>>>>>>>>>>>> the simulation of a pure UTM for the first N
>>>>>>>>>>>>>>>>>>>>>>> steps of simulation we know
>>>>>>>>>>>>>>>>>>>>>>> that it necessarily does provide the actual
>>>>>>>>>>>>>>>>>>>>>>> behavior specified by this
>>>>>>>>>>>>>>>>>>>>>>> input for these N steps.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> And is no longer a UTM, since if fails to meet the
>>>>>>>>>>>>>>>>>>>>>> requirement of a UTM
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> As you already agreed:
>>>>>>>>>>>>>>>>>>>>> The behavior of N steps of ⟨Ĥ⟩ simulated by
>>>>>>>>>>>>>>>>>>>>> embedded_H must are the actual behavior of these N
>>>>>>>>>>>>>>>>>>>>> steps because
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't
>>>>>>>>>>>>>>>>>>>>> change it
>>>>>>>>>>>>>>>>>>>>> (c) Even aborting the simulation after N steps
>>>>>>>>>>>>>>>>>>>>> doesn't change the
>>>>>>>>>>>>>>>>>>>>> first N steps.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> But a UTM doesn't simulate just "N" steps of its
>>>>>>>>>>>>>>>>>>>> input, but ALL of them.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Yet when embedded_H simulates N steps of ⟨Ĥ⟩ this is
>>>>>>>>>>>>>>>>>>> the actual behavior
>>>>>>>>>>>>>>>>>>> of ⟨Ĥ⟩ for these N steps, thus when embedded_H
>>>>>>>>>>>>>>>>>>> simulates 10,000
>>>>>>>>>>>>>>>>>>> recursive simulations these are the actual behavior
>>>>>>>>>>>>>>>>>>> of ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Yes, but doesn't actually show the ACTUAL behavior of
>>>>>>>>>>>>>>>>>> the input as defined,
>>>>>>>>>>>>>>>>> There is only one actual behavior of the actual input
>>>>>>>>>>>>>>>>> and this behavior
>>>>>>>>>>>>>>>>> is correctly demonstrated by N steps of ⟨Ĥ⟩ simulated
>>>>>>>>>>>>>>>>> by embedded_H.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Nope, Read the problem definition.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The behavior to be decided by a Halt Decider is the
>>>>>>>>>>>>>>>> behavior of the ACTUAL MACHINE which is decribed by the
>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No matter what the problem definition says the actual
>>>>>>>>>>>>>>> behavior of the
>>>>>>>>>>>>>>> actual input must necessarily be the N steps simulated by
>>>>>>>>>>>>>>> embedded_H.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The only alternative is to simply disbelieve in UTMs.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> NOPE, Since H isn't a UTM, because it doesn't meet the
>>>>>>>>>>>>>> REQUIREMENTS of a UTM, the statement is meaningless.
>>>>>>>>>>>>> It <is> equivalent to a UTM for the first N steps that can
>>>>>>>>>>>>> include 10,000 recursive simulations.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Which means it ISN'T the Equivalent of a UTM. PERIOD.
>>>>>>>>>>>
>>>>>>>>>>> Why are you playing head games with this?
>>>>>>>>>>>
>>>>>>>>>>> You know and acknowledged that the first N steps of ⟨Ĥ⟩
>>>>>>>>>>> correctly
>>>>>>>>>>> simulated by embedded_H are the actual behavior of ⟨Ĥ⟩ for
>>>>>>>>>>> these first N
>>>>>>>>>>> steps.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Right, but we don't care about that. We care about the TOTAL
>>>>>>>>>> behavior of the input, which H never gets to see, because it
>>>>>>>>>> gives up.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>
>>>>>>>>> N steps of ⟨Ĥ⟩ correctly simulated by embedded_H are the actual
>>>>>>>>> behavior of this input:
>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to embedded_H
>>>>>>>>> (b) embedded_H is applied to ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) which
>>>>>>>>> simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>> (c) *which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the
>>>>>>>>> process*
>>>>>>>>
>>>>>>>> Until the outer embedded_H used by Ĥ reaches the point that it
>>>>>>>> decides to stop its simulation, and the whole simulation ends
>>>>>>>> with just partial results and it decides to go to qn and Ĥ Halts.
>>>>>>>>
>>>>>>>
>>>>>>> You keep dodging the key truth when N steps of embedded_H are
>>>>>>> correctly
>>>>>>> simulated by embedded_H and N = 30000 then we know that the actual
>>>>>>> behavior of ⟨Ĥ⟩ is 10,000 recursive simulations that have never
>>>>>>> reached
>>>>>>> their final state of ⟨Ĥ.qn⟩.
>>>>>>>
>>>>>>
>>>>>> No, it has been shown that if N = 3000, then
>>>>>
>>>>> the actual behavior of ⟨Ĥ⟩ is 10,000 recursive simulations that have
>>>>> never reached their final state of ⟨Ĥ.qn⟩ because ⟨Ĥ⟩ is defined to
>>>>> have
>>>>> a pathological relationship to embedded_H.
>>>>
>>>> No, becasue the ACTUAL BEHAVIOR is defined by the machine that the
>>>> input describes.
>>>>
>>>> PERIOD.
>>>>
>>>>>
>>>>> Referring to an entirely different sequence where there is no such
>>>>> pathological relationship is like comparing apples to lemons and
>>>>> rejecting apples because lemons are too sour.
>>>>
>>>> So, you just don't understand the meaning of ACTUAL BEHAVIOR
>>>>
>>>>>
>>>>> Why do you continue to believe that you can get away with this?
>>>>>
>>>>>
>>>>
>>>> Why do YOU?
>>>>
>>>> Can you name a reliable source that supports your definition? (NOT YOU)
>>>>
>>>> Not just someone you have "tricked" into agreeing to a poorly worded
>>>> statement that yo misinterpret to agree with you.
>>>>
>>>
>>> MIT Professor Michael Sipser has agreed that the following verbatim
>>> paragraph is correct:
>>>
>>> "If simulating halt decider H correctly simulates its input D until H
>>> correctly determines that its simulated D would never stop running
>>> unless aborted then H can abort its simulation of D and correctly report
>>> that D specifies a non-halting sequence of configurations."
>>>
>>> He understood that the above paragraph is a tautology. That you do not
>>> understand that it is a tautology provides zero evidence that it is not
>>> a tautology.
>>>
>>> You have already agreed that N steps of an input simulated by a
>>> simulating halt decider are the actual behavior for these N steps.
>>>
>>> The fact that you agreed with this seems to prove that you will not
>>> disagree with me at the expense of truth and that you do actually care
>>> about the truth.
>>>
>>>
>>>
>>
>> Right, like I said, *IF* the decider correctly simulates its input D
>> until H *CORRECTLY* determines that its Simulate D would never stop
>> running unless aborted.
>>
>> NOTE. THAT MEANS THE ACTUAL MACHIBE OR A UTM SIMULATION OF THE
>> MACHINE. NOT JUST A PARTIAL SIMULATION BY H.
>>
> Unless the simulation is from the frame-of-reference of the pathological
> relationship it is rejecting apples because lemons are too sour.

On 20/04/2023 8:20 pm, olcott wrote:
> On 4/20/2023 2:08 PM, Mr Flibble wrote:
>> On 20/04/2023 6:49 pm, olcott wrote:
>>> On 4/20/2023 12:32 PM, Mr Flibble wrote:
>>>> On 19/04/2023 11:52 pm, olcott wrote:
>>>>> On 4/19/2023 4:14 PM, Mr Flibble wrote:
>>>>>> On 19/04/2023 10:10 pm, olcott wrote:
>>>>>>> On 4/19/2023 3:32 PM, Mr Flibble wrote:
>>>>>>>> On 19/04/2023 8:39 pm, olcott wrote:
>>>>>>>>> On 4/19/2023 1:47 PM, Mr Flibble wrote:
>>>>>>>>>> On 18/04/2023 11:39 pm, olcott wrote:
>>>>>>>>>>> On 4/18/2023 4:55 PM, Mr Flibble wrote:
>>>>>>>>>>>> On 18/04/2023 4:58 pm, olcott wrote:
>>>>>>>>>>>>> On 4/18/2023 6:32 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 4/18/23 1:00 AM, olcott wrote:
>>>>>>>>>>>>>>> A simulating halt decider correctly predicts whether or
>>>>>>>>>>>>>>> not its
>>>>>>>>>>>>>>> correctly simulated input can possibly reach its own
>>>>>>>>>>>>>>> final state and
>>>>>>>>>>>>>>> halt. It does this by correctly recognizing several
>>>>>>>>>>>>>>> non-halting behavior
>>>>>>>>>>>>>>> patterns in a finite number of steps of correct
>>>>>>>>>>>>>>> simulation. Inputs that
>>>>>>>>>>>>>>> do terminate are simply simulated until they complete.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Except t doesn't o this for the "pathological" program.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The "Pathological Program" when built on such a Decider
>>>>>>>>>>>>>> that does give an answer, which you say will be
>>>>>>>>>>>>>> non-halting, and then "Correctly Simulated" by giving it
>>>>>>>>>>>>>> representation to a UTM, we see that the simulation
>>>>>>>>>>>>>> reaches a final state.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Thus, your H was WRONG t make the answer. And the problem
>>>>>>>>>>>>>> is you have added a pattern that isn't always non-halting.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When a simulating halt decider correctly simulates N
>>>>>>>>>>>>>>> steps of its input
>>>>>>>>>>>>>>> it derives the exact same N steps that a pure UTM would
>>>>>>>>>>>>>>> derive because
>>>>>>>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But if ISN'T a "UTM" any more, because some of the
>>>>>>>>>>>>>> features you added have removed essential features needed
>>>>>>>>>>>>>> for it to be an actual UTM. That you make this claim shows
>>>>>>>>>>>>>> you don't actually know what a UTM is.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> This is like saying a NASCAR Racing Car is a Street Legal
>>>>>>>>>>>>>> vehicle, since it started as one and just had some extra
>>>>>>>>>>>>>> features axded.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> My reviewers cannot show that any of the extra features
>>>>>>>>>>>>>>> added to the UTM
>>>>>>>>>>>>>>> change the behavior of the simulated input for the first
>>>>>>>>>>>>>>> N steps of simulation:
>>>>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't change it
>>>>>>>>>>>>>>> (c) Even aborting the simulation after N steps doesn't
>>>>>>>>>>>>>>> change the first N steps.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No one claims that it doesn't correctly reproduce the
>>>>>>>>>>>>>> first N steps of the behavior, that is a Strawman argumen.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Because of all this we can know that the first N steps of
>>>>>>>>>>>>>>> input D
>>>>>>>>>>>>>>> simulated by simulating halt decider H are the actual
>>>>>>>>>>>>>>> behavior that D
>>>>>>>>>>>>>>> presents to H for these same N steps.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *computation that halts*… “the Turing machine will halt
>>>>>>>>>>>>>>> whenever it enters a final state” (Linz:1990:234)rrr
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Right, so we are concerned about the behavior of the
>>>>>>>>>>>>>> ACTUAL machine, not a partial simulation of it.
>>>>>>>>>>>>>> H(D,D) returns non-halting, but D(D) Halts, so the answer
>>>>>>>>>>>>>> is wrong.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When we see (after N steps) that D correctly simulated by
>>>>>>>>>>>>>>> H cannot
>>>>>>>>>>>>>>> possibly reach its simulated final state in any finite
>>>>>>>>>>>>>>> number of steps
>>>>>>>>>>>>>>> of correct simulation then we have conclusive proof that
>>>>>>>>>>>>>>> D presents non-
>>>>>>>>>>>>>>> halting behavior to H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But it isn't "Correctly Simulated by H"
>>>>>>>>>>>>> You agreed that the first N steps are correctly simulated.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It turns out that the non-halting behavior pattern is
>>>>>>>>>>>>> correctly
>>>>>>>>>>>>> recognized in the first N steps.
>>>>>>>>>>>>
>>>>>>>>>>>> Your assumption that a program that calls H is non-halting
>>>>>>>>>>>> is erroneous:
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> My new paper anchors its ideas in actual Turing machines so
>>>>>>>>>>> it is
>>>>>>>>>>> unequivocal. The first two pages re only about the Linz Turing
>>>>>>>>>>> machine based proof.
>>>>>>>>>>>
>>>>>>>>>>> The H/D material is now on a single page and all reference
>>>>>>>>>>> to the x86 language has been stripped and replaced with
>>>>>>>>>>> analysis entirely in C.
>>>>>>>>>>>
>>>>>>>>>>> With this new paper even Richard admits that the first N steps
>>>>>>>>>>> UTM based simulated by a simulating halt decider are
>>>>>>>>>>> necessarily the
>>>>>>>>>>> actual behavior of these N steps.
>>>>>>>>>>>
>>>>>>>>>>> *Simulating (partial) Halt Deciders Defeat the Halting
>>>>>>>>>>> Problem Proofs*
>>>>>>>>>>> https://www.researchgate.net/publication/369971402_Simulating_partial_Halt_Deciders_Defeat_the_Halting_Problem_Proofs
>>>>>>>>>>>
>>>>>>>>>>>> void Px(void (*x)())
>>>>>>>>>>>> {
>>>>>>>>>>>>      (void) H(x, x);
>>>>>>>>>>>>      return;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> Px halts (it discards the result that H returns); your
>>>>>>>>>>>> decider thinks that Px is non-halting which is an obvious
>>>>>>>>>>>> error due to a design flaw in the architecture of your
>>>>>>>>>>>> decider.  Only the Flibble Signaling Simulating Halt Decider
>>>>>>>>>>>> (SSHD) correctly handles this case.
>>>>>>>>>>
>>>>>>>>>> Nope. For H to be a halt decider it must return a halt
>>>>>>>>>> decision to its caller in finite time
>>>>>>>>>
>>>>>>>>> Although H must always return to some caller H is not allowed
>>>>>>>>> to return
>>>>>>>>> to any caller that essentially calls H in infinite recursion.
>>>>>>>>
>>>>>>>> The Flibble Signaling Simulating Halt Decider (SSHD) does not
>>>>>>>> have any infinite recursion thereby proving that
>>>>>>>
>>>>>>> It overrode that behavior that was specified by the machine code
>>>>>>> for Px.
>>>>>>
>>>>>> Nope. You SHD is not a halt decider as
>>>>>
>>>>> I was not even talking about my SHD, I was talking about how your
>>>>> program does its simulation incorrectly.
>>>>
>>>> My SSHD does not do its simulation incorrectly: it does its
>>>> simulation just like I have defined it as evidenced by the fact that
>>>> it returns a correct halting decision for Px; something your broken
>>>> SHD gets wrong.
>>>>
>>>
>>> In order for you to have Px simulated by H terminate normally you
>>> must change the behavior of Px away from the behavior that its x86
>>> code specifies.
>>
>> Your "x86 code" has nothing to do with how my halt decider works; I am
>> using an entirely different simulation method, one that actually works.
>>
>>>
>>> void Px(void (*x)())
>>> {
>>>    (void) H(x, x);
>>>    return;
>>> }
>>>
>>> Px correctly simulated by H cannot possibly reach past its machine
>>> address of: [00001b3d].
>>>
>>> _Px()
>>> [00001b32] 55         push ebp
>>> [00001b33] 8bec       mov ebp,esp
>>> [00001b35] 8b4508     mov eax,[ebp+08]
>>> [00001b38] 50         push eax      // push address of Px
>>> [00001b39] 8b4d08     mov ecx,[ebp+08]
>>> [00001b3c] 51         push ecx      // push address of Px
>>> [00001b3d] e800faffff call 00001542 // Call H
>>> [00001b42] 83c408     add esp,+08
>>> [00001b45] 5d         pop ebp
>>> [00001b46] c3         ret
>>> Size in bytes:(0021) [00001b46]
>>>
>>> What you are doing is the the same as recognizing that _Infinite_Loop()
>>> never halts, forcing it to break out of its infinite loop and jump to
>>> its "ret" instruction
>>>
>>> _Infinite_Loop()
>>> [00001c62] 55         push ebp
>>> [00001c63] 8bec       mov ebp,esp
>>> [00001c65] ebfe       jmp 00001c65
>>> [00001c67] 5d         pop ebp
>>> [00001c68] c3         ret
>>> Size in bytes:(0007) [00001c68]
>>
>> No I am not: there is no infinite loop in Px above; forking the
>> simulation into two branches and returning a different halt decision
>> to each branch is a perfectly valid SHD design; again a design, unlike
>> yours, that actually works.
>
> If you say that Px correctly simulated by H ever reaches its own final
> "return" statement and halts you are incorrect.

On 4/21/2023 7:17 AM, Mr Flibble wrote:
> On 20/04/2023 8:20 pm, olcott wrote:
>> On 4/20/2023 2:08 PM, Mr Flibble wrote:
>>> On 20/04/2023 6:49 pm, olcott wrote:
>>>> On 4/20/2023 12:32 PM, Mr Flibble wrote:
>>>>> On 19/04/2023 11:52 pm, olcott wrote:
>>>>>> On 4/19/2023 4:14 PM, Mr Flibble wrote:
>>>>>>> On 19/04/2023 10:10 pm, olcott wrote:
>>>>>>>> On 4/19/2023 3:32 PM, Mr Flibble wrote:
>>>>>>>>> On 19/04/2023 8:39 pm, olcott wrote:
>>>>>>>>>> On 4/19/2023 1:47 PM, Mr Flibble wrote:
>>>>>>>>>>> On 18/04/2023 11:39 pm, olcott wrote:
>>>>>>>>>>>> On 4/18/2023 4:55 PM, Mr Flibble wrote:
>>>>>>>>>>>>> On 18/04/2023 4:58 pm, olcott wrote:
>>>>>>>>>>>>>> On 4/18/2023 6:32 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 4/18/23 1:00 AM, olcott wrote:
>>>>>>>>>>>>>>>> A simulating halt decider correctly predicts whether or
>>>>>>>>>>>>>>>> not its
>>>>>>>>>>>>>>>> correctly simulated input can possibly reach its own
>>>>>>>>>>>>>>>> final state and
>>>>>>>>>>>>>>>> halt. It does this by correctly recognizing several
>>>>>>>>>>>>>>>> non-halting behavior
>>>>>>>>>>>>>>>> patterns in a finite number of steps of correct
>>>>>>>>>>>>>>>> simulation. Inputs that
>>>>>>>>>>>>>>>> do terminate are simply simulated until they complete.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Except t doesn't o this for the "pathological" program.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The "Pathological Program" when built on such a Decider
>>>>>>>>>>>>>>> that does give an answer, which you say will be
>>>>>>>>>>>>>>> non-halting, and then "Correctly Simulated" by giving it
>>>>>>>>>>>>>>> representation to a UTM, we see that the simulation
>>>>>>>>>>>>>>> reaches a final state.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Thus, your H was WRONG t make the answer. And the problem
>>>>>>>>>>>>>>> is you have added a pattern that isn't always non-halting.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When a simulating halt decider correctly simulates N
>>>>>>>>>>>>>>>> steps of its input
>>>>>>>>>>>>>>>> it derives the exact same N steps that a pure UTM would
>>>>>>>>>>>>>>>> derive because
>>>>>>>>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But if ISN'T a "UTM" any more, because some of the
>>>>>>>>>>>>>>> features you added have removed essential features needed
>>>>>>>>>>>>>>> for it to be an actual UTM. That you make this claim
>>>>>>>>>>>>>>> shows you don't actually know what a UTM is.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> This is like saying a NASCAR Racing Car is a Street Legal
>>>>>>>>>>>>>>> vehicle, since it started as one and just had some extra
>>>>>>>>>>>>>>> features axded.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> My reviewers cannot show that any of the extra features
>>>>>>>>>>>>>>>> added to the UTM
>>>>>>>>>>>>>>>> change the behavior of the simulated input for the first
>>>>>>>>>>>>>>>> N steps of simulation:
>>>>>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't
>>>>>>>>>>>>>>>> change it
>>>>>>>>>>>>>>>> (c) Even aborting the simulation after N steps doesn't
>>>>>>>>>>>>>>>> change the first N steps.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No one claims that it doesn't correctly reproduce the
>>>>>>>>>>>>>>> first N steps of the behavior, that is a Strawman argumen.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Because of all this we can know that the first N steps
>>>>>>>>>>>>>>>> of input D
>>>>>>>>>>>>>>>> simulated by simulating halt decider H are the actual
>>>>>>>>>>>>>>>> behavior that D
>>>>>>>>>>>>>>>> presents to H for these same N steps.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *computation that halts*… “the Turing machine will halt
>>>>>>>>>>>>>>>> whenever it enters a final state” (Linz:1990:234)rrr
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Right, so we are concerned about the behavior of the
>>>>>>>>>>>>>>> ACTUAL machine, not a partial simulation of it.
>>>>>>>>>>>>>>> H(D,D) returns non-halting, but D(D) Halts, so the answer
>>>>>>>>>>>>>>> is wrong.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When we see (after N steps) that D correctly simulated
>>>>>>>>>>>>>>>> by H cannot
>>>>>>>>>>>>>>>> possibly reach its simulated final state in any finite
>>>>>>>>>>>>>>>> number of steps
>>>>>>>>>>>>>>>> of correct simulation then we have conclusive proof that
>>>>>>>>>>>>>>>> D presents non-
>>>>>>>>>>>>>>>> halting behavior to H.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But it isn't "Correctly Simulated by H"
>>>>>>>>>>>>>> You agreed that the first N steps are correctly simulated.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It turns out that the non-halting behavior pattern is
>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>> recognized in the first N steps.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Your assumption that a program that calls H is non-halting
>>>>>>>>>>>>> is erroneous:
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> My new paper anchors its ideas in actual Turing machines so
>>>>>>>>>>>> it is
>>>>>>>>>>>> unequivocal. The first two pages re only about the Linz Turing
>>>>>>>>>>>> machine based proof.
>>>>>>>>>>>>
>>>>>>>>>>>> The H/D material is now on a single page and all reference
>>>>>>>>>>>> to the x86 language has been stripped and replaced with
>>>>>>>>>>>> analysis entirely in C.
>>>>>>>>>>>>
>>>>>>>>>>>> With this new paper even Richard admits that the first N steps
>>>>>>>>>>>> UTM based simulated by a simulating halt decider are
>>>>>>>>>>>> necessarily the
>>>>>>>>>>>> actual behavior of these N steps.
>>>>>>>>>>>>
>>>>>>>>>>>> *Simulating (partial) Halt Deciders Defeat the Halting
>>>>>>>>>>>> Problem Proofs*
>>>>>>>>>>>> https://www.researchgate.net/publication/369971402_Simulating_partial_Halt_Deciders_Defeat_the_Halting_Problem_Proofs
>>>>>>>>>>>>
>>>>>>>>>>>>> void Px(void (*x)())
>>>>>>>>>>>>> {
>>>>>>>>>>>>>      (void) H(x, x);
>>>>>>>>>>>>>      return;
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> Px halts (it discards the result that H returns); your
>>>>>>>>>>>>> decider thinks that Px is non-halting which is an obvious
>>>>>>>>>>>>> error due to a design flaw in the architecture of your
>>>>>>>>>>>>> decider.  Only the Flibble Signaling Simulating Halt
>>>>>>>>>>>>> Decider (SSHD) correctly handles this case.
>>>>>>>>>>>
>>>>>>>>>>> Nope. For H to be a halt decider it must return a halt
>>>>>>>>>>> decision to its caller in finite time
>>>>>>>>>>
>>>>>>>>>> Although H must always return to some caller H is not allowed
>>>>>>>>>> to return
>>>>>>>>>> to any caller that essentially calls H in infinite recursion.
>>>>>>>>>
>>>>>>>>> The Flibble Signaling Simulating Halt Decider (SSHD) does not
>>>>>>>>> have any infinite recursion thereby proving that
>>>>>>>>
>>>>>>>> It overrode that behavior that was specified by the machine code
>>>>>>>> for Px.
>>>>>>>
>>>>>>> Nope. You SHD is not a halt decider as
>>>>>>
>>>>>> I was not even talking about my SHD, I was talking about how your
>>>>>> program does its simulation incorrectly.
>>>>>
>>>>> My SSHD does not do its simulation incorrectly: it does its
>>>>> simulation just like I have defined it as evidenced by the fact
>>>>> that it returns a correct halting decision for Px; something your
>>>>> broken SHD gets wrong.
>>>>>
>>>>
>>>> In order for you to have Px simulated by H terminate normally you
>>>> must change the behavior of Px away from the behavior that its x86
>>>> code specifies.
>>>
>>> Your "x86 code" has nothing to do with how my halt decider works; I
>>> am using an entirely different simulation method, one that actually
>>> works.
>>>
>>>>
>>>> void Px(void (*x)())
>>>> {
>>>>    (void) H(x, x);
>>>>    return;
>>>> }
>>>>
>>>> Px correctly simulated by H cannot possibly reach past its machine
>>>> address of: [00001b3d].
>>>>
>>>> _Px()
>>>> [00001b32] 55         push ebp
>>>> [00001b33] 8bec       mov ebp,esp
>>>> [00001b35] 8b4508     mov eax,[ebp+08]
>>>> [00001b38] 50         push eax      // push address of Px
>>>> [00001b39] 8b4d08     mov ecx,[ebp+08]
>>>> [00001b3c] 51         push ecx      // push address of Px
>>>> [00001b3d] e800faffff call 00001542 // Call H
>>>> [00001b42] 83c408     add esp,+08
>>>> [00001b45] 5d         pop ebp
>>>> [00001b46] c3         ret
>>>> Size in bytes:(0021) [00001b46]
>>>>
>>>> What you are doing is the the same as recognizing that _Infinite_Loop()
>>>> never halts, forcing it to break out of its infinite loop and jump to
>>>> its "ret" instruction
>>>>
>>>> _Infinite_Loop()
>>>> [00001c62] 55         push ebp
>>>> [00001c63] 8bec       mov ebp,esp
>>>> [00001c65] ebfe       jmp 00001c65
>>>> [00001c67] 5d         pop ebp
>>>> [00001c68] c3         ret
>>>> Size in bytes:(0007) [00001c68]
>>>
>>> No I am not: there is no infinite loop in Px above; forking the
>>> simulation into two branches and returning a different halt decision
>>> to each branch is a perfectly valid SHD design; again a design,
>>> unlike yours, that actually works.
>>
>> If you say that Px correctly simulated by H ever reaches its own final
>> "return" statement and halts you are incorrect.
>
> Px halts if H is (or is part of) a genuine halt decider.

On 4/21/2023 6:18 AM, Richard Damon wrote:
> On 4/20/23 10:43 PM, olcott wrote:
>> On 4/20/2023 9:20 PM, Richard Damon wrote:
>>> On 4/20/23 10:05 PM, olcott wrote:
>>>> On 4/20/2023 6:14 PM, Richard Damon wrote:
>>>>> On 4/20/23 6:51 PM, olcott wrote:
>>>>>> On 4/20/2023 5:40 PM, Richard Damon wrote:
>>>>>>> On 4/20/23 10:59 AM, olcott wrote:
>>>>>>>> On 4/20/2023 7:06 AM, Richard Damon wrote:
>>>>>>>>> On 4/20/23 7:56 AM, olcott wrote:
>>>>>>>>>> On 4/20/2023 6:23 AM, Richard Damon wrote:
>>>>>>>>>>> On 4/20/23 12:04 AM, olcott wrote:
>>>>>>>>>>>> On 4/19/2023 10:41 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 4/19/23 11:29 PM, olcott wrote:
>>>>>>>>>>>>>> On 4/19/2023 9:16 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 4/19/23 9:59 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 4/19/2023 8:38 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 4/19/23 9:25 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 4/19/2023 8:08 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 4/19/23 8:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 4/19/2023 7:45 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 4/19/23 8:31 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 4/19/2023 7:07 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 4/19/23 7:16 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 4/19/2023 5:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 4/19/23 11:05 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/19/2023 6:14 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 4/18/23 11:48 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> *You keep slip sliding with the fallacy of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> equivocation error*
>>>>>>>>>>>>>>>>>>>>>>>>>>>> The actual simulated input: ⟨Ĥ⟩ that
>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H must compute its mapping
>>>>>>>>>>>>>>>>>>>>>>>>>>>> from never reaches its simulated final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>> of ⟨Ĥ.qn⟩ even after 10,000
>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct recursive simulations
>>>>>>>>>>>>>>>>>>>>>>>>>>>> because ⟨Ĥ⟩ is defined to have
>>>>>>>>>>>>>>>>>>>>>>>>>>>> a pathological relationship to embedded_H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> An YOU keep on falling into your Strawman
>>>>>>>>>>>>>>>>>>>>>>>>>>> error. The question is NOT what does the
>>>>>>>>>>>>>>>>>>>>>>>>>>> "simulation by H" show, but what is the
>>>>>>>>>>>>>>>>>>>>>>>>>>> actual behavior of the actual machine the
>>>>>>>>>>>>>>>>>>>>>>>>>>> input represents.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> When a simulating halt decider correctly
>>>>>>>>>>>>>>>>>>>>>>>>>> simulates N steps of its input
>>>>>>>>>>>>>>>>>>>>>>>>>> it derives the exact same N steps that a pure
>>>>>>>>>>>>>>>>>>>>>>>>>> UTM would derive because
>>>>>>>>>>>>>>>>>>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> No, it ISN'T a UTM because if fails to meeet
>>>>>>>>>>>>>>>>>>>>>>>>> the definition of a UTM.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> You are just proving that you are a
>>>>>>>>>>>>>>>>>>>>>>>>> pathological liar that doesn't know what he is
>>>>>>>>>>>>>>>>>>>>>>>>> talking about.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> My reviewers cannot show that any of the extra
>>>>>>>>>>>>>>>>>>>>>>>>>> features added to the UTM
>>>>>>>>>>>>>>>>>>>>>>>>>> change the behavior of the simulated input for
>>>>>>>>>>>>>>>>>>>>>>>>>> the first N steps of
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation:
>>>>>>>>>>>>>>>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>>>>>>>>>>>>>>>> (b) Matching non-halting behavior patterns
>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't change it
>>>>>>>>>>>>>>>>>>>>>>>>>> (c) Even aborting the simulation after N steps
>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't change the first N steps.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Which don't matter, as the question
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> The actual behavior that the actual input: ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>> represents is the
>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of the simulation of N steps by
>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H because embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>> has the exact same behavior as a UTM for these
>>>>>>>>>>>>>>>>>>>>>>>>>> first N steps, and you
>>>>>>>>>>>>>>>>>>>>>>>>>> already agreed with this.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> No, the actual behavior of the input is what
>>>>>>>>>>>>>>>>>>>>>>>>> the MACHINE Ĥ applied to (Ĥ) does.
>>>>>>>>>>>>>>>>>>>>>>>> Because embedded_H is a UTM that has been
>>>>>>>>>>>>>>>>>>>>>>>> augmented with three features
>>>>>>>>>>>>>>>>>>>>>>>> that cannot possibly cause its simulation of its
>>>>>>>>>>>>>>>>>>>>>>>> input to diverge from
>>>>>>>>>>>>>>>>>>>>>>>> the simulation of a pure UTM for the first N
>>>>>>>>>>>>>>>>>>>>>>>> steps of simulation we know
>>>>>>>>>>>>>>>>>>>>>>>> that it necessarily does provide the actual
>>>>>>>>>>>>>>>>>>>>>>>> behavior specified by this
>>>>>>>>>>>>>>>>>>>>>>>> input for these N steps.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> And is no longer a UTM, since if fails to meet
>>>>>>>>>>>>>>>>>>>>>>> the requirement of a UTM
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> As you already agreed:
>>>>>>>>>>>>>>>>>>>>>> The behavior of N steps of ⟨Ĥ⟩ simulated by
>>>>>>>>>>>>>>>>>>>>>> embedded_H must are the actual behavior of these N
>>>>>>>>>>>>>>>>>>>>>> steps because
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>>>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't
>>>>>>>>>>>>>>>>>>>>>> change it
>>>>>>>>>>>>>>>>>>>>>> (c) Even aborting the simulation after N steps
>>>>>>>>>>>>>>>>>>>>>> doesn't change the
>>>>>>>>>>>>>>>>>>>>>> first N steps.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> But a UTM doesn't simulate just "N" steps of its
>>>>>>>>>>>>>>>>>>>>> input, but ALL of them.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Yet when embedded_H simulates N steps of ⟨Ĥ⟩ this is
>>>>>>>>>>>>>>>>>>>> the actual behavior
>>>>>>>>>>>>>>>>>>>> of ⟨Ĥ⟩ for these N steps, thus when embedded_H
>>>>>>>>>>>>>>>>>>>> simulates 10,000
>>>>>>>>>>>>>>>>>>>> recursive simulations these are the actual behavior
>>>>>>>>>>>>>>>>>>>> of ⟨Ĥ⟩.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Yes, but doesn't actually show the ACTUAL behavior of
>>>>>>>>>>>>>>>>>>> the input as defined,
>>>>>>>>>>>>>>>>>> There is only one actual behavior of the actual input
>>>>>>>>>>>>>>>>>> and this behavior
>>>>>>>>>>>>>>>>>> is correctly demonstrated by N steps of ⟨Ĥ⟩ simulated
>>>>>>>>>>>>>>>>>> by embedded_H.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Nope, Read the problem definition.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The behavior to be decided by a Halt Decider is the
>>>>>>>>>>>>>>>>> behavior of the ACTUAL MACHINE which is decribed by the
>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No matter what the problem definition says the actual
>>>>>>>>>>>>>>>> behavior of the
>>>>>>>>>>>>>>>> actual input must necessarily be the N steps simulated
>>>>>>>>>>>>>>>> by embedded_H.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The only alternative is to simply disbelieve in UTMs.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> NOPE, Since H isn't a UTM, because it doesn't meet the
>>>>>>>>>>>>>>> REQUIREMENTS of a UTM, the statement is meaningless.
>>>>>>>>>>>>>> It <is> equivalent to a UTM for the first N steps that can
>>>>>>>>>>>>>> include 10,000 recursive simulations.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Which means it ISN'T the Equivalent of a UTM. PERIOD.
>>>>>>>>>>>>
>>>>>>>>>>>> Why are you playing head games with this?
>>>>>>>>>>>>
>>>>>>>>>>>> You know and acknowledged that the first N steps of ⟨Ĥ⟩
>>>>>>>>>>>> correctly
>>>>>>>>>>>> simulated by embedded_H are the actual behavior of ⟨Ĥ⟩ for
>>>>>>>>>>>> these first N
>>>>>>>>>>>> steps.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Right, but we don't care about that. We care about the TOTAL
>>>>>>>>>>> behavior of the input, which H never gets to see, because it
>>>>>>>>>>> gives up.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>
>>>>>>>>>> N steps of ⟨Ĥ⟩ correctly simulated by embedded_H are the
>>>>>>>>>> actual behavior of this input:
>>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to embedded_H
>>>>>>>>>> (b) embedded_H is applied to ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) which
>>>>>>>>>> simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>> (c) *which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the
>>>>>>>>>> process*
>>>>>>>>>
>>>>>>>>> Until the outer embedded_H used by Ĥ reaches the point that it
>>>>>>>>> decides to stop its simulation, and the whole simulation ends
>>>>>>>>> with just partial results and it decides to go to qn and Ĥ Halts.
>>>>>>>>>
>>>>>>>>
>>>>>>>> You keep dodging the key truth when N steps of embedded_H are
>>>>>>>> correctly
>>>>>>>> simulated by embedded_H and N = 30000 then we know that the actual
>>>>>>>> behavior of ⟨Ĥ⟩ is 10,000 recursive simulations that have never
>>>>>>>> reached
>>>>>>>> their final state of ⟨Ĥ.qn⟩.
>>>>>>>>
>>>>>>>
>>>>>>> No, it has been shown that if N = 3000, then
>>>>>>
>>>>>> the actual behavior of ⟨Ĥ⟩ is 10,000 recursive simulations that have
>>>>>> never reached their final state of ⟨Ĥ.qn⟩ because ⟨Ĥ⟩ is defined
>>>>>> to have
>>>>>> a pathological relationship to embedded_H.
>>>>>
>>>>> No, becasue the ACTUAL BEHAVIOR is defined by the machine that the
>>>>> input describes.
>>>>>
>>>>> PERIOD.
>>>>>
>>>>>>
>>>>>> Referring to an entirely different sequence where there is no such
>>>>>> pathological relationship is like comparing apples to lemons and
>>>>>> rejecting apples because lemons are too sour.
>>>>>
>>>>> So, you just don't understand the meaning of ACTUAL BEHAVIOR
>>>>>
>>>>>>
>>>>>> Why do you continue to believe that you can get away with this?
>>>>>>
>>>>>>
>>>>>
>>>>> Why do YOU?
>>>>>
>>>>> Can you name a reliable source that supports your definition? (NOT
>>>>> YOU)
>>>>>
>>>>> Not just someone you have "tricked" into agreeing to a poorly
>>>>> worded statement that yo misinterpret to agree with you.
>>>>>
>>>>
>>>> MIT Professor Michael Sipser has agreed that the following verbatim
>>>> paragraph is correct:
>>>>
>>>> "If simulating halt decider H correctly simulates its input D until H
>>>> correctly determines that its simulated D would never stop running
>>>> unless aborted then H can abort its simulation of D and correctly
>>>> report
>>>> that D specifies a non-halting sequence of configurations."
>>>>
>>>> He understood that the above paragraph is a tautology. That you do not
>>>> understand that it is a tautology provides zero evidence that it is not
>>>> a tautology.
>>>>
>>>> You have already agreed that N steps of an input simulated by a
>>>> simulating halt decider are the actual behavior for these N steps.
>>>>
>>>> The fact that you agreed with this seems to prove that you will not
>>>> disagree with me at the expense of truth and that you do actually care
>>>> about the truth.
>>>>
>>>>
>>>>
>>>
>>> Right, like I said, *IF* the decider correctly simulates its input D
>>> until H *CORRECTLY* determines that its Simulate D would never stop
>>> running unless aborted.
>>>
>>> NOTE. THAT MEANS THE ACTUAL MACHIBE OR A UTM SIMULATION OF THE
>>> MACHINE. NOT JUST A PARTIAL SIMULATION BY H.
>>>
>> Unless the simulation is from the frame-of-reference of the pathological
>> relationship it is rejecting apples because lemons are too sour.
>
> So, you don't understand the nature of simulation.
>

On 21/04/2023 4:16 pm, olcott wrote:
> On 4/21/2023 7:17 AM, Mr Flibble wrote:
>> On 20/04/2023 8:20 pm, olcott wrote:
>>> On 4/20/2023 2:08 PM, Mr Flibble wrote:
>>>> On 20/04/2023 6:49 pm, olcott wrote:
>>>>> On 4/20/2023 12:32 PM, Mr Flibble wrote:
>>>>>> On 19/04/2023 11:52 pm, olcott wrote:
>>>>>>> On 4/19/2023 4:14 PM, Mr Flibble wrote:
>>>>>>>> On 19/04/2023 10:10 pm, olcott wrote:
>>>>>>>>> On 4/19/2023 3:32 PM, Mr Flibble wrote:
>>>>>>>>>> On 19/04/2023 8:39 pm, olcott wrote:
>>>>>>>>>>> On 4/19/2023 1:47 PM, Mr Flibble wrote:
>>>>>>>>>>>> On 18/04/2023 11:39 pm, olcott wrote:
>>>>>>>>>>>>> On 4/18/2023 4:55 PM, Mr Flibble wrote:
>>>>>>>>>>>>>> On 18/04/2023 4:58 pm, olcott wrote:
>>>>>>>>>>>>>>> On 4/18/2023 6:32 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 4/18/23 1:00 AM, olcott wrote:
>>>>>>>>>>>>>>>>> A simulating halt decider correctly predicts whether or
>>>>>>>>>>>>>>>>> not its
>>>>>>>>>>>>>>>>> correctly simulated input can possibly reach its own
>>>>>>>>>>>>>>>>> final state and
>>>>>>>>>>>>>>>>> halt. It does this by correctly recognizing several
>>>>>>>>>>>>>>>>> non-halting behavior
>>>>>>>>>>>>>>>>> patterns in a finite number of steps of correct
>>>>>>>>>>>>>>>>> simulation. Inputs that
>>>>>>>>>>>>>>>>> do terminate are simply simulated until they complete.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Except t doesn't o this for the "pathological" program.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The "Pathological Program" when built on such a Decider
>>>>>>>>>>>>>>>> that does give an answer, which you say will be
>>>>>>>>>>>>>>>> non-halting, and then "Correctly Simulated" by giving it
>>>>>>>>>>>>>>>> representation to a UTM, we see that the simulation
>>>>>>>>>>>>>>>> reaches a final state.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Thus, your H was WRONG t make the answer. And the
>>>>>>>>>>>>>>>> problem is you have added a pattern that isn't always
>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> When a simulating halt decider correctly simulates N
>>>>>>>>>>>>>>>>> steps of its input
>>>>>>>>>>>>>>>>> it derives the exact same N steps that a pure UTM would
>>>>>>>>>>>>>>>>> derive because
>>>>>>>>>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But if ISN'T a "UTM" any more, because some of the
>>>>>>>>>>>>>>>> features you added have removed essential features
>>>>>>>>>>>>>>>> needed for it to be an actual UTM. That you make this
>>>>>>>>>>>>>>>> claim shows you don't actually know what a UTM is.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> This is like saying a NASCAR Racing Car is a Street
>>>>>>>>>>>>>>>> Legal vehicle, since it started as one and just had some
>>>>>>>>>>>>>>>> extra features axded.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> My reviewers cannot show that any of the extra features
>>>>>>>>>>>>>>>>> added to the UTM
>>>>>>>>>>>>>>>>> change the behavior of the simulated input for the
>>>>>>>>>>>>>>>>> first N steps of simulation:
>>>>>>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't
>>>>>>>>>>>>>>>>> change it
>>>>>>>>>>>>>>>>> (c) Even aborting the simulation after N steps doesn't
>>>>>>>>>>>>>>>>> change the first N steps.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No one claims that it doesn't correctly reproduce the
>>>>>>>>>>>>>>>> first N steps of the behavior, that is a Strawman argumen.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Because of all this we can know that the first N steps
>>>>>>>>>>>>>>>>> of input D
>>>>>>>>>>>>>>>>> simulated by simulating halt decider H are the actual
>>>>>>>>>>>>>>>>> behavior that D
>>>>>>>>>>>>>>>>> presents to H for these same N steps.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *computation that halts*… “the Turing machine will halt
>>>>>>>>>>>>>>>>> whenever it enters a final state” (Linz:1990:234)rrr
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Right, so we are concerned about the behavior of the
>>>>>>>>>>>>>>>> ACTUAL machine, not a partial simulation of it.
>>>>>>>>>>>>>>>> H(D,D) returns non-halting, but D(D) Halts, so the
>>>>>>>>>>>>>>>> answer is wrong.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> When we see (after N steps) that D correctly simulated
>>>>>>>>>>>>>>>>> by H cannot
>>>>>>>>>>>>>>>>> possibly reach its simulated final state in any finite
>>>>>>>>>>>>>>>>> number of steps
>>>>>>>>>>>>>>>>> of correct simulation then we have conclusive proof
>>>>>>>>>>>>>>>>> that D presents non-
>>>>>>>>>>>>>>>>> halting behavior to H.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But it isn't "Correctly Simulated by H"
>>>>>>>>>>>>>>> You agreed that the first N steps are correctly simulated.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It turns out that the non-halting behavior pattern is
>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>> recognized in the first N steps.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Your assumption that a program that calls H is non-halting
>>>>>>>>>>>>>> is erroneous:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> My new paper anchors its ideas in actual Turing machines so
>>>>>>>>>>>>> it is
>>>>>>>>>>>>> unequivocal. The first two pages re only about the Linz Turing
>>>>>>>>>>>>> machine based proof.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The H/D material is now on a single page and all reference
>>>>>>>>>>>>> to the x86 language has been stripped and replaced with
>>>>>>>>>>>>> analysis entirely in C.
>>>>>>>>>>>>>
>>>>>>>>>>>>> With this new paper even Richard admits that the first N steps
>>>>>>>>>>>>> UTM based simulated by a simulating halt decider are
>>>>>>>>>>>>> necessarily the
>>>>>>>>>>>>> actual behavior of these N steps.
>>>>>>>>>>>>>
>>>>>>>>>>>>> *Simulating (partial) Halt Deciders Defeat the Halting
>>>>>>>>>>>>> Problem Proofs*
>>>>>>>>>>>>> https://www.researchgate.net/publication/369971402_Simulating_partial_Halt_Deciders_Defeat_the_Halting_Problem_Proofs
>>>>>>>>>>>>>
>>>>>>>>>>>>>> void Px(void (*x)())
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>      (void) H(x, x);
>>>>>>>>>>>>>>      return;
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Px halts (it discards the result that H returns); your
>>>>>>>>>>>>>> decider thinks that Px is non-halting which is an obvious
>>>>>>>>>>>>>> error due to a design flaw in the architecture of your
>>>>>>>>>>>>>> decider.  Only the Flibble Signaling Simulating Halt
>>>>>>>>>>>>>> Decider (SSHD) correctly handles this case.
>>>>>>>>>>>>
>>>>>>>>>>>> Nope. For H to be a halt decider it must return a halt
>>>>>>>>>>>> decision to its caller in finite time
>>>>>>>>>>>
>>>>>>>>>>> Although H must always return to some caller H is not allowed
>>>>>>>>>>> to return
>>>>>>>>>>> to any caller that essentially calls H in infinite recursion.
>>>>>>>>>>
>>>>>>>>>> The Flibble Signaling Simulating Halt Decider (SSHD) does not
>>>>>>>>>> have any infinite recursion thereby proving that
>>>>>>>>>
>>>>>>>>> It overrode that behavior that was specified by the machine
>>>>>>>>> code for Px.
>>>>>>>>
>>>>>>>> Nope. You SHD is not a halt decider as
>>>>>>>
>>>>>>> I was not even talking about my SHD, I was talking about how your
>>>>>>> program does its simulation incorrectly.
>>>>>>
>>>>>> My SSHD does not do its simulation incorrectly: it does its
>>>>>> simulation just like I have defined it as evidenced by the fact
>>>>>> that it returns a correct halting decision for Px; something your
>>>>>> broken SHD gets wrong.
>>>>>>
>>>>>
>>>>> In order for you to have Px simulated by H terminate normally you
>>>>> must change the behavior of Px away from the behavior that its x86
>>>>> code specifies.
>>>>
>>>> Your "x86 code" has nothing to do with how my halt decider works; I
>>>> am using an entirely different simulation method, one that actually
>>>> works.
>>>>
>>>>>
>>>>> void Px(void (*x)())
>>>>> {
>>>>>    (void) H(x, x);
>>>>>    return;
>>>>> }
>>>>>
>>>>> Px correctly simulated by H cannot possibly reach past its machine
>>>>> address of: [00001b3d].
>>>>>
>>>>> _Px()
>>>>> [00001b32] 55         push ebp
>>>>> [00001b33] 8bec       mov ebp,esp
>>>>> [00001b35] 8b4508     mov eax,[ebp+08]
>>>>> [00001b38] 50         push eax      // push address of Px
>>>>> [00001b39] 8b4d08     mov ecx,[ebp+08]
>>>>> [00001b3c] 51         push ecx      // push address of Px
>>>>> [00001b3d] e800faffff call 00001542 // Call H
>>>>> [00001b42] 83c408     add esp,+08
>>>>> [00001b45] 5d         pop ebp
>>>>> [00001b46] c3         ret
>>>>> Size in bytes:(0021) [00001b46]
>>>>>
>>>>> What you are doing is the the same as recognizing that
>>>>> _Infinite_Loop()
>>>>> never halts, forcing it to break out of its infinite loop and jump to
>>>>> its "ret" instruction
>>>>>
>>>>> _Infinite_Loop()
>>>>> [00001c62] 55         push ebp
>>>>> [00001c63] 8bec       mov ebp,esp
>>>>> [00001c65] ebfe       jmp 00001c65
>>>>> [00001c67] 5d         pop ebp
>>>>> [00001c68] c3         ret
>>>>> Size in bytes:(0007) [00001c68]
>>>>
>>>> No I am not: there is no infinite loop in Px above; forking the
>>>> simulation into two branches and returning a different halt decision
>>>> to each branch is a perfectly valid SHD design; again a design,
>>>> unlike yours, that actually works.
>>>
>>> If you say that Px correctly simulated by H ever reaches its own final
>>> "return" statement and halts you are incorrect.
>>
>> Px halts if H is (or is part of) a genuine halt decider.
>
> The simulated Px only halts if it reaches its own final state in a
> finite number of steps of correct simulation. It can't possibly do this.

On 4/21/2023 11:36 AM, Mr Flibble wrote:
> On 21/04/2023 4:16 pm, olcott wrote:
>> On 4/21/2023 7:17 AM, Mr Flibble wrote:
>>> On 20/04/2023 8:20 pm, olcott wrote:
>>>> On 4/20/2023 2:08 PM, Mr Flibble wrote:
>>>>> On 20/04/2023 6:49 pm, olcott wrote:
>>>>>> On 4/20/2023 12:32 PM, Mr Flibble wrote:
>>>>>>> On 19/04/2023 11:52 pm, olcott wrote:
>>>>>>>> On 4/19/2023 4:14 PM, Mr Flibble wrote:
>>>>>>>>> On 19/04/2023 10:10 pm, olcott wrote:
>>>>>>>>>> On 4/19/2023 3:32 PM, Mr Flibble wrote:
>>>>>>>>>>> On 19/04/2023 8:39 pm, olcott wrote:
>>>>>>>>>>>> On 4/19/2023 1:47 PM, Mr Flibble wrote:
>>>>>>>>>>>>> On 18/04/2023 11:39 pm, olcott wrote:
>>>>>>>>>>>>>> On 4/18/2023 4:55 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On 18/04/2023 4:58 pm, olcott wrote:
>>>>>>>>>>>>>>>> On 4/18/2023 6:32 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 4/18/23 1:00 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> A simulating halt decider correctly predicts whether
>>>>>>>>>>>>>>>>>> or not its
>>>>>>>>>>>>>>>>>> correctly simulated input can possibly reach its own
>>>>>>>>>>>>>>>>>> final state and
>>>>>>>>>>>>>>>>>> halt. It does this by correctly recognizing several
>>>>>>>>>>>>>>>>>> non-halting behavior
>>>>>>>>>>>>>>>>>> patterns in a finite number of steps of correct
>>>>>>>>>>>>>>>>>> simulation. Inputs that
>>>>>>>>>>>>>>>>>> do terminate are simply simulated until they complete.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Except t doesn't o this for the "pathological" program.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The "Pathological Program" when built on such a Decider
>>>>>>>>>>>>>>>>> that does give an answer, which you say will be
>>>>>>>>>>>>>>>>> non-halting, and then "Correctly Simulated" by giving
>>>>>>>>>>>>>>>>> it representation to a UTM, we see that the simulation
>>>>>>>>>>>>>>>>> reaches a final state.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Thus, your H was WRONG t make the answer. And the
>>>>>>>>>>>>>>>>> problem is you have added a pattern that isn't always
>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When a simulating halt decider correctly simulates N
>>>>>>>>>>>>>>>>>> steps of its input
>>>>>>>>>>>>>>>>>> it derives the exact same N steps that a pure UTM
>>>>>>>>>>>>>>>>>> would derive because
>>>>>>>>>>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But if ISN'T a "UTM" any more, because some of the
>>>>>>>>>>>>>>>>> features you added have removed essential features
>>>>>>>>>>>>>>>>> needed for it to be an actual UTM. That you make this
>>>>>>>>>>>>>>>>> claim shows you don't actually know what a UTM is.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> This is like saying a NASCAR Racing Car is a Street
>>>>>>>>>>>>>>>>> Legal vehicle, since it started as one and just had
>>>>>>>>>>>>>>>>> some extra features axded.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> My reviewers cannot show that any of the extra
>>>>>>>>>>>>>>>>>> features added to the UTM
>>>>>>>>>>>>>>>>>> change the behavior of the simulated input for the
>>>>>>>>>>>>>>>>>> first N steps of simulation:
>>>>>>>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't
>>>>>>>>>>>>>>>>>> change it
>>>>>>>>>>>>>>>>>> (c) Even aborting the simulation after N steps doesn't
>>>>>>>>>>>>>>>>>> change the first N steps.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No one claims that it doesn't correctly reproduce the
>>>>>>>>>>>>>>>>> first N steps of the behavior, that is a Strawman argumen.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Because of all this we can know that the first N steps
>>>>>>>>>>>>>>>>>> of input D
>>>>>>>>>>>>>>>>>> simulated by simulating halt decider H are the actual
>>>>>>>>>>>>>>>>>> behavior that D
>>>>>>>>>>>>>>>>>> presents to H for these same N steps.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *computation that halts*… “the Turing machine will
>>>>>>>>>>>>>>>>>> halt whenever it enters a final state” (Linz:1990:234)rrr
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Right, so we are concerned about the behavior of the
>>>>>>>>>>>>>>>>> ACTUAL machine, not a partial simulation of it.
>>>>>>>>>>>>>>>>> H(D,D) returns non-halting, but D(D) Halts, so the
>>>>>>>>>>>>>>>>> answer is wrong.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When we see (after N steps) that D correctly simulated
>>>>>>>>>>>>>>>>>> by H cannot
>>>>>>>>>>>>>>>>>> possibly reach its simulated final state in any finite
>>>>>>>>>>>>>>>>>> number of steps
>>>>>>>>>>>>>>>>>> of correct simulation then we have conclusive proof
>>>>>>>>>>>>>>>>>> that D presents non-
>>>>>>>>>>>>>>>>>> halting behavior to H.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But it isn't "Correctly Simulated by H"
>>>>>>>>>>>>>>>> You agreed that the first N steps are correctly simulated.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It turns out that the non-halting behavior pattern is
>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>> recognized in the first N steps.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Your assumption that a program that calls H is
>>>>>>>>>>>>>>> non-halting is erroneous:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> My new paper anchors its ideas in actual Turing machines
>>>>>>>>>>>>>> so it is
>>>>>>>>>>>>>> unequivocal. The first two pages re only about the Linz
>>>>>>>>>>>>>> Turing
>>>>>>>>>>>>>> machine based proof.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The H/D material is now on a single page and all reference
>>>>>>>>>>>>>> to the x86 language has been stripped and replaced with
>>>>>>>>>>>>>> analysis entirely in C.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> With this new paper even Richard admits that the first N
>>>>>>>>>>>>>> steps
>>>>>>>>>>>>>> UTM based simulated by a simulating halt decider are
>>>>>>>>>>>>>> necessarily the
>>>>>>>>>>>>>> actual behavior of these N steps.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *Simulating (partial) Halt Deciders Defeat the Halting
>>>>>>>>>>>>>> Problem Proofs*
>>>>>>>>>>>>>> https://www.researchgate.net/publication/369971402_Simulating_partial_Halt_Deciders_Defeat_the_Halting_Problem_Proofs
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> void Px(void (*x)())
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>      (void) H(x, x);
>>>>>>>>>>>>>>>      return;
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Px halts (it discards the result that H returns); your
>>>>>>>>>>>>>>> decider thinks that Px is non-halting which is an obvious
>>>>>>>>>>>>>>> error due to a design flaw in the architecture of your
>>>>>>>>>>>>>>> decider.  Only the Flibble Signaling Simulating Halt
>>>>>>>>>>>>>>> Decider (SSHD) correctly handles this case.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope. For H to be a halt decider it must return a halt
>>>>>>>>>>>>> decision to its caller in finite time
>>>>>>>>>>>>
>>>>>>>>>>>> Although H must always return to some caller H is not
>>>>>>>>>>>> allowed to return
>>>>>>>>>>>> to any caller that essentially calls H in infinite recursion.
>>>>>>>>>>>
>>>>>>>>>>> The Flibble Signaling Simulating Halt Decider (SSHD) does not
>>>>>>>>>>> have any infinite recursion thereby proving that
>>>>>>>>>>
>>>>>>>>>> It overrode that behavior that was specified by the machine
>>>>>>>>>> code for Px.
>>>>>>>>>
>>>>>>>>> Nope. You SHD is not a halt decider as
>>>>>>>>
>>>>>>>> I was not even talking about my SHD, I was talking about how
>>>>>>>> your program does its simulation incorrectly.
>>>>>>>
>>>>>>> My SSHD does not do its simulation incorrectly: it does its
>>>>>>> simulation just like I have defined it as evidenced by the fact
>>>>>>> that it returns a correct halting decision for Px; something your
>>>>>>> broken SHD gets wrong.
>>>>>>>
>>>>>>
>>>>>> In order for you to have Px simulated by H terminate normally you
>>>>>> must change the behavior of Px away from the behavior that its x86
>>>>>> code specifies.
>>>>>
>>>>> Your "x86 code" has nothing to do with how my halt decider works; I
>>>>> am using an entirely different simulation method, one that actually
>>>>> works.
>>>>>
>>>>>>
>>>>>> void Px(void (*x)())
>>>>>> {
>>>>>>    (void) H(x, x);
>>>>>>    return;
>>>>>> }
>>>>>>
>>>>>> Px correctly simulated by H cannot possibly reach past its machine
>>>>>> address of: [00001b3d].
>>>>>>
>>>>>> _Px()
>>>>>> [00001b32] 55         push ebp
>>>>>> [00001b33] 8bec       mov ebp,esp
>>>>>> [00001b35] 8b4508     mov eax,[ebp+08]
>>>>>> [00001b38] 50         push eax      // push address of Px
>>>>>> [00001b39] 8b4d08     mov ecx,[ebp+08]
>>>>>> [00001b3c] 51         push ecx      // push address of Px
>>>>>> [00001b3d] e800faffff call 00001542 // Call H
>>>>>> [00001b42] 83c408     add esp,+08
>>>>>> [00001b45] 5d         pop ebp
>>>>>> [00001b46] c3         ret
>>>>>> Size in bytes:(0021) [00001b46]
>>>>>>
>>>>>> What you are doing is the the same as recognizing that
>>>>>> _Infinite_Loop()
>>>>>> never halts, forcing it to break out of its infinite loop and jump to
>>>>>> its "ret" instruction
>>>>>>
>>>>>> _Infinite_Loop()
>>>>>> [00001c62] 55         push ebp
>>>>>> [00001c63] 8bec       mov ebp,esp
>>>>>> [00001c65] ebfe       jmp 00001c65
>>>>>> [00001c67] 5d         pop ebp
>>>>>> [00001c68] c3         ret
>>>>>> Size in bytes:(0007) [00001c68]
>>>>>
>>>>> No I am not: there is no infinite loop in Px above; forking the
>>>>> simulation into two branches and returning a different halt
>>>>> decision to each branch is a perfectly valid SHD design; again a
>>>>> design, unlike yours, that actually works.
>>>>
>>>> If you say that Px correctly simulated by H ever reaches its own final
>>>> "return" statement and halts you are incorrect.
>>>
>>> Px halts if H is (or is part of) a genuine halt decider.
>>
>> The simulated Px only halts if it reaches its own final state in a
>> finite number of steps of correct simulation. It can't possibly do this.
>
> Nope, a correctly simulated Px will allow it to reach its own final
> state (termination); your H does NOT perform a correct simulation
> because your H is broken.
>
> /Flibble
>

On 21/04/2023 5:41 pm, olcott wrote:
> On 4/21/2023 11:36 AM, Mr Flibble wrote:
>> On 21/04/2023 4:16 pm, olcott wrote:
>>> On 4/21/2023 7:17 AM, Mr Flibble wrote:
>>>> On 20/04/2023 8:20 pm, olcott wrote:
>>>>> On 4/20/2023 2:08 PM, Mr Flibble wrote:
>>>>>> On 20/04/2023 6:49 pm, olcott wrote:
>>>>>>> On 4/20/2023 12:32 PM, Mr Flibble wrote:
>>>>>>>> On 19/04/2023 11:52 pm, olcott wrote:
>>>>>>>>> On 4/19/2023 4:14 PM, Mr Flibble wrote:
>>>>>>>>>> On 19/04/2023 10:10 pm, olcott wrote:
>>>>>>>>>>> On 4/19/2023 3:32 PM, Mr Flibble wrote:
>>>>>>>>>>>> On 19/04/2023 8:39 pm, olcott wrote:
>>>>>>>>>>>>> On 4/19/2023 1:47 PM, Mr Flibble wrote:
>>>>>>>>>>>>>> On 18/04/2023 11:39 pm, olcott wrote:
>>>>>>>>>>>>>>> On 4/18/2023 4:55 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>> On 18/04/2023 4:58 pm, olcott wrote:
>>>>>>>>>>>>>>>>> On 4/18/2023 6:32 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 4/18/23 1:00 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> A simulating halt decider correctly predicts whether
>>>>>>>>>>>>>>>>>>> or not its
>>>>>>>>>>>>>>>>>>> correctly simulated input can possibly reach its own
>>>>>>>>>>>>>>>>>>> final state and
>>>>>>>>>>>>>>>>>>> halt. It does this by correctly recognizing several
>>>>>>>>>>>>>>>>>>> non-halting behavior
>>>>>>>>>>>>>>>>>>> patterns in a finite number of steps of correct
>>>>>>>>>>>>>>>>>>> simulation. Inputs that
>>>>>>>>>>>>>>>>>>> do terminate are simply simulated until they complete.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Except t doesn't o this for the "pathological" program.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The "Pathological Program" when built on such a
>>>>>>>>>>>>>>>>>> Decider that does give an answer, which you say will
>>>>>>>>>>>>>>>>>> be non-halting, and then "Correctly Simulated" by
>>>>>>>>>>>>>>>>>> giving it representation to a UTM, we see that the
>>>>>>>>>>>>>>>>>> simulation reaches a final state.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Thus, your H was WRONG t make the answer. And the
>>>>>>>>>>>>>>>>>> problem is you have added a pattern that isn't always
>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> When a simulating halt decider correctly simulates N
>>>>>>>>>>>>>>>>>>> steps of its input
>>>>>>>>>>>>>>>>>>> it derives the exact same N steps that a pure UTM
>>>>>>>>>>>>>>>>>>> would derive because
>>>>>>>>>>>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> But if ISN'T a "UTM" any more, because some of the
>>>>>>>>>>>>>>>>>> features you added have removed essential features
>>>>>>>>>>>>>>>>>> needed for it to be an actual UTM. That you make this
>>>>>>>>>>>>>>>>>> claim shows you don't actually know what a UTM is.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> This is like saying a NASCAR Racing Car is a Street
>>>>>>>>>>>>>>>>>> Legal vehicle, since it started as one and just had
>>>>>>>>>>>>>>>>>> some extra features axded.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> My reviewers cannot show that any of the extra
>>>>>>>>>>>>>>>>>>> features added to the UTM
>>>>>>>>>>>>>>>>>>> change the behavior of the simulated input for the
>>>>>>>>>>>>>>>>>>> first N steps of simulation:
>>>>>>>>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't
>>>>>>>>>>>>>>>>>>> change it
>>>>>>>>>>>>>>>>>>> (c) Even aborting the simulation after N steps
>>>>>>>>>>>>>>>>>>> doesn't change the first N steps.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> No one claims that it doesn't correctly reproduce the
>>>>>>>>>>>>>>>>>> first N steps of the behavior, that is a Strawman
>>>>>>>>>>>>>>>>>> argumen.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Because of all this we can know that the first N
>>>>>>>>>>>>>>>>>>> steps of input D
>>>>>>>>>>>>>>>>>>> simulated by simulating halt decider H are the actual
>>>>>>>>>>>>>>>>>>> behavior that D
>>>>>>>>>>>>>>>>>>> presents to H for these same N steps.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *computation that halts*… “the Turing machine will
>>>>>>>>>>>>>>>>>>> halt whenever it enters a final state”
>>>>>>>>>>>>>>>>>>> (Linz:1990:234)rrr
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Right, so we are concerned about the behavior of the
>>>>>>>>>>>>>>>>>> ACTUAL machine, not a partial simulation of it.
>>>>>>>>>>>>>>>>>> H(D,D) returns non-halting, but D(D) Halts, so the
>>>>>>>>>>>>>>>>>> answer is wrong.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> When we see (after N steps) that D correctly
>>>>>>>>>>>>>>>>>>> simulated by H cannot
>>>>>>>>>>>>>>>>>>> possibly reach its simulated final state in any
>>>>>>>>>>>>>>>>>>> finite number of steps
>>>>>>>>>>>>>>>>>>> of correct simulation then we have conclusive proof
>>>>>>>>>>>>>>>>>>> that D presents non-
>>>>>>>>>>>>>>>>>>> halting behavior to H.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> But it isn't "Correctly Simulated by H"
>>>>>>>>>>>>>>>>> You agreed that the first N steps are correctly simulated.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It turns out that the non-halting behavior pattern is
>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>> recognized in the first N steps.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Your assumption that a program that calls H is
>>>>>>>>>>>>>>>> non-halting is erroneous:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> My new paper anchors its ideas in actual Turing machines
>>>>>>>>>>>>>>> so it is
>>>>>>>>>>>>>>> unequivocal. The first two pages re only about the Linz
>>>>>>>>>>>>>>> Turing
>>>>>>>>>>>>>>> machine based proof.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The H/D material is now on a single page and all reference
>>>>>>>>>>>>>>> to the x86 language has been stripped and replaced with
>>>>>>>>>>>>>>> analysis entirely in C.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> With this new paper even Richard admits that the first N
>>>>>>>>>>>>>>> steps
>>>>>>>>>>>>>>> UTM based simulated by a simulating halt decider are
>>>>>>>>>>>>>>> necessarily the
>>>>>>>>>>>>>>> actual behavior of these N steps.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *Simulating (partial) Halt Deciders Defeat the Halting
>>>>>>>>>>>>>>> Problem Proofs*
>>>>>>>>>>>>>>> https://www.researchgate.net/publication/369971402_Simulating_partial_Halt_Deciders_Defeat_the_Halting_Problem_Proofs
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> void Px(void (*x)())
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>      (void) H(x, x);
>>>>>>>>>>>>>>>>      return;
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Px halts (it discards the result that H returns); your
>>>>>>>>>>>>>>>> decider thinks that Px is non-halting which is an
>>>>>>>>>>>>>>>> obvious error due to a design flaw in the architecture
>>>>>>>>>>>>>>>> of your decider.  Only the Flibble Signaling Simulating
>>>>>>>>>>>>>>>> Halt Decider (SSHD) correctly handles this case.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Nope. For H to be a halt decider it must return a halt
>>>>>>>>>>>>>> decision to its caller in finite time
>>>>>>>>>>>>>
>>>>>>>>>>>>> Although H must always return to some caller H is not
>>>>>>>>>>>>> allowed to return
>>>>>>>>>>>>> to any caller that essentially calls H in infinite recursion.
>>>>>>>>>>>>
>>>>>>>>>>>> The Flibble Signaling Simulating Halt Decider (SSHD) does
>>>>>>>>>>>> not have any infinite recursion thereby proving that
>>>>>>>>>>>
>>>>>>>>>>> It overrode that behavior that was specified by the machine
>>>>>>>>>>> code for Px.
>>>>>>>>>>
>>>>>>>>>> Nope. You SHD is not a halt decider as
>>>>>>>>>
>>>>>>>>> I was not even talking about my SHD, I was talking about how
>>>>>>>>> your program does its simulation incorrectly.
>>>>>>>>
>>>>>>>> My SSHD does not do its simulation incorrectly: it does its
>>>>>>>> simulation just like I have defined it as evidenced by the fact
>>>>>>>> that it returns a correct halting decision for Px; something
>>>>>>>> your broken SHD gets wrong.
>>>>>>>>
>>>>>>>
>>>>>>> In order for you to have Px simulated by H terminate normally you
>>>>>>> must change the behavior of Px away from the behavior that its
>>>>>>> x86 code specifies.
>>>>>>
>>>>>> Your "x86 code" has nothing to do with how my halt decider works;
>>>>>> I am using an entirely different simulation method, one that
>>>>>> actually works.
>>>>>>
>>>>>>>
>>>>>>> void Px(void (*x)())
>>>>>>> {
>>>>>>>    (void) H(x, x);
>>>>>>>    return;
>>>>>>> }
>>>>>>>
>>>>>>> Px correctly simulated by H cannot possibly reach past its
>>>>>>> machine address of: [00001b3d].
>>>>>>>
>>>>>>> _Px()
>>>>>>> [00001b32] 55         push ebp
>>>>>>> [00001b33] 8bec       mov ebp,esp
>>>>>>> [00001b35] 8b4508     mov eax,[ebp+08]
>>>>>>> [00001b38] 50         push eax      // push address of Px
>>>>>>> [00001b39] 8b4d08     mov ecx,[ebp+08]
>>>>>>> [00001b3c] 51         push ecx      // push address of Px
>>>>>>> [00001b3d] e800faffff call 00001542 // Call H
>>>>>>> [00001b42] 83c408     add esp,+08
>>>>>>> [00001b45] 5d         pop ebp
>>>>>>> [00001b46] c3         ret
>>>>>>> Size in bytes:(0021) [00001b46]
>>>>>>>
>>>>>>> What you are doing is the the same as recognizing that
>>>>>>> _Infinite_Loop()
>>>>>>> never halts, forcing it to break out of its infinite loop and
>>>>>>> jump to
>>>>>>> its "ret" instruction
>>>>>>>
>>>>>>> _Infinite_Loop()
>>>>>>> [00001c62] 55         push ebp
>>>>>>> [00001c63] 8bec       mov ebp,esp
>>>>>>> [00001c65] ebfe       jmp 00001c65
>>>>>>> [00001c67] 5d         pop ebp
>>>>>>> [00001c68] c3         ret
>>>>>>> Size in bytes:(0007) [00001c68]
>>>>>>
>>>>>> No I am not: there is no infinite loop in Px above; forking the
>>>>>> simulation into two branches and returning a different halt
>>>>>> decision to each branch is a perfectly valid SHD design; again a
>>>>>> design, unlike yours, that actually works.
>>>>>
>>>>> If you say that Px correctly simulated by H ever reaches its own final
>>>>> "return" statement and halts you are incorrect.
>>>>
>>>> Px halts if H is (or is part of) a genuine halt decider.
>>>
>>> The simulated Px only halts if it reaches its own final state in a
>>> finite number of steps of correct simulation. It can't possibly do this.
>>
>> Nope, a correctly simulated Px will allow it to reach its own final
>> state (termination); your H does NOT perform a correct simulation
>> because your H is broken.
>>
>> /Flibble
>>
>
> Strawman deception
> Px correctly simulated by H will never reach its own simulated final
> state of "return" because Px and H have a pathological relationship to
> each other.

On 4/21/2023 12:42 PM, Mr Flibble wrote:
> On 21/04/2023 5:41 pm, olcott wrote:
>> On 4/21/2023 11:36 AM, Mr Flibble wrote:
>>> On 21/04/2023 4:16 pm, olcott wrote:
>>>> On 4/21/2023 7:17 AM, Mr Flibble wrote:
>>>>> On 20/04/2023 8:20 pm, olcott wrote:
>>>>>> On 4/20/2023 2:08 PM, Mr Flibble wrote:
>>>>>>> On 20/04/2023 6:49 pm, olcott wrote:
>>>>>>>> On 4/20/2023 12:32 PM, Mr Flibble wrote:
>>>>>>>>> On 19/04/2023 11:52 pm, olcott wrote:
>>>>>>>>>> On 4/19/2023 4:14 PM, Mr Flibble wrote:
>>>>>>>>>>> On 19/04/2023 10:10 pm, olcott wrote:
>>>>>>>>>>>> On 4/19/2023 3:32 PM, Mr Flibble wrote:
>>>>>>>>>>>>> On 19/04/2023 8:39 pm, olcott wrote:
>>>>>>>>>>>>>> On 4/19/2023 1:47 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On 18/04/2023 11:39 pm, olcott wrote:
>>>>>>>>>>>>>>>> On 4/18/2023 4:55 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>> On 18/04/2023 4:58 pm, olcott wrote:
>>>>>>>>>>>>>>>>>> On 4/18/2023 6:32 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 4/18/23 1:00 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> A simulating halt decider correctly predicts whether
>>>>>>>>>>>>>>>>>>>> or not its
>>>>>>>>>>>>>>>>>>>> correctly simulated input can possibly reach its own
>>>>>>>>>>>>>>>>>>>> final state and
>>>>>>>>>>>>>>>>>>>> halt. It does this by correctly recognizing several
>>>>>>>>>>>>>>>>>>>> non-halting behavior
>>>>>>>>>>>>>>>>>>>> patterns in a finite number of steps of correct
>>>>>>>>>>>>>>>>>>>> simulation. Inputs that
>>>>>>>>>>>>>>>>>>>> do terminate are simply simulated until they complete.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Except t doesn't o this for the "pathological" program.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The "Pathological Program" when built on such a
>>>>>>>>>>>>>>>>>>> Decider that does give an answer, which you say will
>>>>>>>>>>>>>>>>>>> be non-halting, and then "Correctly Simulated" by
>>>>>>>>>>>>>>>>>>> giving it representation to a UTM, we see that the
>>>>>>>>>>>>>>>>>>> simulation reaches a final state.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Thus, your H was WRONG t make the answer. And the
>>>>>>>>>>>>>>>>>>> problem is you have added a pattern that isn't always
>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> When a simulating halt decider correctly simulates N
>>>>>>>>>>>>>>>>>>>> steps of its input
>>>>>>>>>>>>>>>>>>>> it derives the exact same N steps that a pure UTM
>>>>>>>>>>>>>>>>>>>> would derive because
>>>>>>>>>>>>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> But if ISN'T a "UTM" any more, because some of the
>>>>>>>>>>>>>>>>>>> features you added have removed essential features
>>>>>>>>>>>>>>>>>>> needed for it to be an actual UTM. That you make this
>>>>>>>>>>>>>>>>>>> claim shows you don't actually know what a UTM is.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> This is like saying a NASCAR Racing Car is a Street
>>>>>>>>>>>>>>>>>>> Legal vehicle, since it started as one and just had
>>>>>>>>>>>>>>>>>>> some extra features axded.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> My reviewers cannot show that any of the extra
>>>>>>>>>>>>>>>>>>>> features added to the UTM
>>>>>>>>>>>>>>>>>>>> change the behavior of the simulated input for the
>>>>>>>>>>>>>>>>>>>> first N steps of simulation:
>>>>>>>>>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't
>>>>>>>>>>>>>>>>>>>> change it
>>>>>>>>>>>>>>>>>>>> (c) Even aborting the simulation after N steps
>>>>>>>>>>>>>>>>>>>> doesn't change the first N steps.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No one claims that it doesn't correctly reproduce the
>>>>>>>>>>>>>>>>>>> first N steps of the behavior, that is a Strawman
>>>>>>>>>>>>>>>>>>> argumen.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Because of all this we can know that the first N
>>>>>>>>>>>>>>>>>>>> steps of input D
>>>>>>>>>>>>>>>>>>>> simulated by simulating halt decider H are the
>>>>>>>>>>>>>>>>>>>> actual behavior that D
>>>>>>>>>>>>>>>>>>>> presents to H for these same N steps.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *computation that halts*… “the Turing machine will
>>>>>>>>>>>>>>>>>>>> halt whenever it enters a final state”
>>>>>>>>>>>>>>>>>>>> (Linz:1990:234)rrr
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Right, so we are concerned about the behavior of the
>>>>>>>>>>>>>>>>>>> ACTUAL machine, not a partial simulation of it.
>>>>>>>>>>>>>>>>>>> H(D,D) returns non-halting, but D(D) Halts, so the
>>>>>>>>>>>>>>>>>>> answer is wrong.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> When we see (after N steps) that D correctly
>>>>>>>>>>>>>>>>>>>> simulated by H cannot
>>>>>>>>>>>>>>>>>>>> possibly reach its simulated final state in any
>>>>>>>>>>>>>>>>>>>> finite number of steps
>>>>>>>>>>>>>>>>>>>> of correct simulation then we have conclusive proof
>>>>>>>>>>>>>>>>>>>> that D presents non-
>>>>>>>>>>>>>>>>>>>> halting behavior to H.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> But it isn't "Correctly Simulated by H"
>>>>>>>>>>>>>>>>>> You agreed that the first N steps are correctly
>>>>>>>>>>>>>>>>>> simulated.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It turns out that the non-halting behavior pattern is
>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>> recognized in the first N steps.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Your assumption that a program that calls H is
>>>>>>>>>>>>>>>>> non-halting is erroneous:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> My new paper anchors its ideas in actual Turing machines
>>>>>>>>>>>>>>>> so it is
>>>>>>>>>>>>>>>> unequivocal. The first two pages re only about the Linz
>>>>>>>>>>>>>>>> Turing
>>>>>>>>>>>>>>>> machine based proof.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The H/D material is now on a single page and all reference
>>>>>>>>>>>>>>>> to the x86 language has been stripped and replaced with
>>>>>>>>>>>>>>>> analysis entirely in C.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> With this new paper even Richard admits that the first N
>>>>>>>>>>>>>>>> steps
>>>>>>>>>>>>>>>> UTM based simulated by a simulating halt decider are
>>>>>>>>>>>>>>>> necessarily the
>>>>>>>>>>>>>>>> actual behavior of these N steps.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *Simulating (partial) Halt Deciders Defeat the Halting
>>>>>>>>>>>>>>>> Problem Proofs*
>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/369971402_Simulating_partial_Halt_Deciders_Defeat_the_Halting_Problem_Proofs
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> void Px(void (*x)())
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>      (void) H(x, x);
>>>>>>>>>>>>>>>>>      return;
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Px halts (it discards the result that H returns); your
>>>>>>>>>>>>>>>>> decider thinks that Px is non-halting which is an
>>>>>>>>>>>>>>>>> obvious error due to a design flaw in the architecture
>>>>>>>>>>>>>>>>> of your decider.  Only the Flibble Signaling Simulating
>>>>>>>>>>>>>>>>> Halt Decider (SSHD) correctly handles this case.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Nope. For H to be a halt decider it must return a halt
>>>>>>>>>>>>>>> decision to its caller in finite time
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Although H must always return to some caller H is not
>>>>>>>>>>>>>> allowed to return
>>>>>>>>>>>>>> to any caller that essentially calls H in infinite recursion.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The Flibble Signaling Simulating Halt Decider (SSHD) does
>>>>>>>>>>>>> not have any infinite recursion thereby proving that
>>>>>>>>>>>>
>>>>>>>>>>>> It overrode that behavior that was specified by the machine
>>>>>>>>>>>> code for Px.
>>>>>>>>>>>
>>>>>>>>>>> Nope. You SHD is not a halt decider as
>>>>>>>>>>
>>>>>>>>>> I was not even talking about my SHD, I was talking about how
>>>>>>>>>> your program does its simulation incorrectly.
>>>>>>>>>
>>>>>>>>> My SSHD does not do its simulation incorrectly: it does its
>>>>>>>>> simulation just like I have defined it as evidenced by the fact
>>>>>>>>> that it returns a correct halting decision for Px; something
>>>>>>>>> your broken SHD gets wrong.
>>>>>>>>>
>>>>>>>>
>>>>>>>> In order for you to have Px simulated by H terminate normally
>>>>>>>> you must change the behavior of Px away from the behavior that
>>>>>>>> its x86 code specifies.
>>>>>>>
>>>>>>> Your "x86 code" has nothing to do with how my halt decider works;
>>>>>>> I am using an entirely different simulation method, one that
>>>>>>> actually works.
>>>>>>>
>>>>>>>>
>>>>>>>> void Px(void (*x)())
>>>>>>>> {
>>>>>>>>    (void) H(x, x);
>>>>>>>>    return;
>>>>>>>> }
>>>>>>>>
>>>>>>>> Px correctly simulated by H cannot possibly reach past its
>>>>>>>> machine address of: [00001b3d].
>>>>>>>>
>>>>>>>> _Px()
>>>>>>>> [00001b32] 55         push ebp
>>>>>>>> [00001b33] 8bec       mov ebp,esp
>>>>>>>> [00001b35] 8b4508     mov eax,[ebp+08]
>>>>>>>> [00001b38] 50         push eax      // push address of Px
>>>>>>>> [00001b39] 8b4d08     mov ecx,[ebp+08]
>>>>>>>> [00001b3c] 51         push ecx      // push address of Px
>>>>>>>> [00001b3d] e800faffff call 00001542 // Call H
>>>>>>>> [00001b42] 83c408     add esp,+08
>>>>>>>> [00001b45] 5d         pop ebp
>>>>>>>> [00001b46] c3         ret
>>>>>>>> Size in bytes:(0021) [00001b46]
>>>>>>>>
>>>>>>>> What you are doing is the the same as recognizing that
>>>>>>>> _Infinite_Loop()
>>>>>>>> never halts, forcing it to break out of its infinite loop and
>>>>>>>> jump to
>>>>>>>> its "ret" instruction
>>>>>>>>
>>>>>>>> _Infinite_Loop()
>>>>>>>> [00001c62] 55         push ebp
>>>>>>>> [00001c63] 8bec       mov ebp,esp
>>>>>>>> [00001c65] ebfe       jmp 00001c65
>>>>>>>> [00001c67] 5d         pop ebp
>>>>>>>> [00001c68] c3         ret
>>>>>>>> Size in bytes:(0007) [00001c68]
>>>>>>>
>>>>>>> No I am not: there is no infinite loop in Px above; forking the
>>>>>>> simulation into two branches and returning a different halt
>>>>>>> decision to each branch is a perfectly valid SHD design; again a
>>>>>>> design, unlike yours, that actually works.
>>>>>>
>>>>>> If you say that Px correctly simulated by H ever reaches its own
>>>>>> final
>>>>>> "return" statement and halts you are incorrect.
>>>>>
>>>>> Px halts if H is (or is part of) a genuine halt decider.
>>>>
>>>> The simulated Px only halts if it reaches its own final state in a
>>>> finite number of steps of correct simulation. It can't possibly do
>>>> this.
>>>
>>> Nope, a correctly simulated Px will allow it to reach its own final
>>> state (termination); your H does NOT perform a correct simulation
>>> because your H is broken.
>>>
>>> /Flibble
>>>
>>
>> Strawman deception
>> Px correctly simulated by H will never reach its own simulated final
>> state of "return" because Px and H have a pathological relationship to
>> each other.
>
> Nope, there is no pathological relationship between Px and H because Px
> discards the result of H (i.e. it does not try to do the opposite of the
> H halting result as per the definition of the Halting Problem).
>

On 21/04/2023 7:36 pm, olcott wrote:
> On 4/21/2023 12:42 PM, Mr Flibble wrote:
>> On 21/04/2023 5:41 pm, olcott wrote:
>>> On 4/21/2023 11:36 AM, Mr Flibble wrote:
>>>> On 21/04/2023 4:16 pm, olcott wrote:
>>>>> On 4/21/2023 7:17 AM, Mr Flibble wrote:
>>>>>> On 20/04/2023 8:20 pm, olcott wrote:
>>>>>>> On 4/20/2023 2:08 PM, Mr Flibble wrote:
>>>>>>>> On 20/04/2023 6:49 pm, olcott wrote:
>>>>>>>>> On 4/20/2023 12:32 PM, Mr Flibble wrote:
>>>>>>>>>> On 19/04/2023 11:52 pm, olcott wrote:
>>>>>>>>>>> On 4/19/2023 4:14 PM, Mr Flibble wrote:
>>>>>>>>>>>> On 19/04/2023 10:10 pm, olcott wrote:
>>>>>>>>>>>>> On 4/19/2023 3:32 PM, Mr Flibble wrote:
>>>>>>>>>>>>>> On 19/04/2023 8:39 pm, olcott wrote:
>>>>>>>>>>>>>>> On 4/19/2023 1:47 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>> On 18/04/2023 11:39 pm, olcott wrote:
>>>>>>>>>>>>>>>>> On 4/18/2023 4:55 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>> On 18/04/2023 4:58 pm, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 4/18/2023 6:32 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 4/18/23 1:00 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> A simulating halt decider correctly predicts
>>>>>>>>>>>>>>>>>>>>> whether or not its
>>>>>>>>>>>>>>>>>>>>> correctly simulated input can possibly reach its
>>>>>>>>>>>>>>>>>>>>> own final state and
>>>>>>>>>>>>>>>>>>>>> halt. It does this by correctly recognizing several
>>>>>>>>>>>>>>>>>>>>> non-halting behavior
>>>>>>>>>>>>>>>>>>>>> patterns in a finite number of steps of correct
>>>>>>>>>>>>>>>>>>>>> simulation. Inputs that
>>>>>>>>>>>>>>>>>>>>> do terminate are simply simulated until they complete.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Except t doesn't o this for the "pathological" program.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The "Pathological Program" when built on such a
>>>>>>>>>>>>>>>>>>>> Decider that does give an answer, which you say will
>>>>>>>>>>>>>>>>>>>> be non-halting, and then "Correctly Simulated" by
>>>>>>>>>>>>>>>>>>>> giving it representation to a UTM, we see that the
>>>>>>>>>>>>>>>>>>>> simulation reaches a final state.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Thus, your H was WRONG t make the answer. And the
>>>>>>>>>>>>>>>>>>>> problem is you have added a pattern that isn't
>>>>>>>>>>>>>>>>>>>> always non-halting.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> When a simulating halt decider correctly simulates
>>>>>>>>>>>>>>>>>>>>> N steps of its input
>>>>>>>>>>>>>>>>>>>>> it derives the exact same N steps that a pure UTM
>>>>>>>>>>>>>>>>>>>>> would derive because
>>>>>>>>>>>>>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> But if ISN'T a "UTM" any more, because some of the
>>>>>>>>>>>>>>>>>>>> features you added have removed essential features
>>>>>>>>>>>>>>>>>>>> needed for it to be an actual UTM. That you make
>>>>>>>>>>>>>>>>>>>> this claim shows you don't actually know what a UTM is.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> This is like saying a NASCAR Racing Car is a Street
>>>>>>>>>>>>>>>>>>>> Legal vehicle, since it started as one and just had
>>>>>>>>>>>>>>>>>>>> some extra features axded.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> My reviewers cannot show that any of the extra
>>>>>>>>>>>>>>>>>>>>> features added to the UTM
>>>>>>>>>>>>>>>>>>>>> change the behavior of the simulated input for the
>>>>>>>>>>>>>>>>>>>>> first N steps of simulation:
>>>>>>>>>>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't
>>>>>>>>>>>>>>>>>>>>> change it
>>>>>>>>>>>>>>>>>>>>> (c) Even aborting the simulation after N steps
>>>>>>>>>>>>>>>>>>>>> doesn't change the first N steps.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> No one claims that it doesn't correctly reproduce
>>>>>>>>>>>>>>>>>>>> the first N steps of the behavior, that is a
>>>>>>>>>>>>>>>>>>>> Strawman argumen.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Because of all this we can know that the first N
>>>>>>>>>>>>>>>>>>>>> steps of input D
>>>>>>>>>>>>>>>>>>>>> simulated by simulating halt decider H are the
>>>>>>>>>>>>>>>>>>>>> actual behavior that D
>>>>>>>>>>>>>>>>>>>>> presents to H for these same N steps.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *computation that halts*… “the Turing machine will
>>>>>>>>>>>>>>>>>>>>> halt whenever it enters a final state”
>>>>>>>>>>>>>>>>>>>>> (Linz:1990:234)rrr
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Right, so we are concerned about the behavior of the
>>>>>>>>>>>>>>>>>>>> ACTUAL machine, not a partial simulation of it.
>>>>>>>>>>>>>>>>>>>> H(D,D) returns non-halting, but D(D) Halts, so the
>>>>>>>>>>>>>>>>>>>> answer is wrong.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> When we see (after N steps) that D correctly
>>>>>>>>>>>>>>>>>>>>> simulated by H cannot
>>>>>>>>>>>>>>>>>>>>> possibly reach its simulated final state in any
>>>>>>>>>>>>>>>>>>>>> finite number of steps
>>>>>>>>>>>>>>>>>>>>> of correct simulation then we have conclusive proof
>>>>>>>>>>>>>>>>>>>>> that D presents non-
>>>>>>>>>>>>>>>>>>>>> halting behavior to H.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> But it isn't "Correctly Simulated by H"
>>>>>>>>>>>>>>>>>>> You agreed that the first N steps are correctly
>>>>>>>>>>>>>>>>>>> simulated.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It turns out that the non-halting behavior pattern is
>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>> recognized in the first N steps.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Your assumption that a program that calls H is
>>>>>>>>>>>>>>>>>> non-halting is erroneous:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> My new paper anchors its ideas in actual Turing
>>>>>>>>>>>>>>>>> machines so it is
>>>>>>>>>>>>>>>>> unequivocal. The first two pages re only about the Linz
>>>>>>>>>>>>>>>>> Turing
>>>>>>>>>>>>>>>>> machine based proof.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The H/D material is now on a single page and all reference
>>>>>>>>>>>>>>>>> to the x86 language has been stripped and replaced with
>>>>>>>>>>>>>>>>> analysis entirely in C.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> With this new paper even Richard admits that the first
>>>>>>>>>>>>>>>>> N steps
>>>>>>>>>>>>>>>>> UTM based simulated by a simulating halt decider are
>>>>>>>>>>>>>>>>> necessarily the
>>>>>>>>>>>>>>>>> actual behavior of these N steps.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *Simulating (partial) Halt Deciders Defeat the Halting
>>>>>>>>>>>>>>>>> Problem Proofs*
>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/369971402_Simulating_partial_Halt_Deciders_Defeat_the_Halting_Problem_Proofs
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> void Px(void (*x)())
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>      (void) H(x, x);
>>>>>>>>>>>>>>>>>>      return;
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Px halts (it discards the result that H returns); your
>>>>>>>>>>>>>>>>>> decider thinks that Px is non-halting which is an
>>>>>>>>>>>>>>>>>> obvious error due to a design flaw in the architecture
>>>>>>>>>>>>>>>>>> of your decider.  Only the Flibble Signaling
>>>>>>>>>>>>>>>>>> Simulating Halt Decider (SSHD) correctly handles this
>>>>>>>>>>>>>>>>>> case.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Nope. For H to be a halt decider it must return a halt
>>>>>>>>>>>>>>>> decision to its caller in finite time
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Although H must always return to some caller H is not
>>>>>>>>>>>>>>> allowed to return
>>>>>>>>>>>>>>> to any caller that essentially calls H in infinite
>>>>>>>>>>>>>>> recursion.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The Flibble Signaling Simulating Halt Decider (SSHD) does
>>>>>>>>>>>>>> not have any infinite recursion thereby proving that
>>>>>>>>>>>>>
>>>>>>>>>>>>> It overrode that behavior that was specified by the machine
>>>>>>>>>>>>> code for Px.
>>>>>>>>>>>>
>>>>>>>>>>>> Nope. You SHD is not a halt decider as
>>>>>>>>>>>
>>>>>>>>>>> I was not even talking about my SHD, I was talking about how
>>>>>>>>>>> your program does its simulation incorrectly.
>>>>>>>>>>
>>>>>>>>>> My SSHD does not do its simulation incorrectly: it does its
>>>>>>>>>> simulation just like I have defined it as evidenced by the
>>>>>>>>>> fact that it returns a correct halting decision for Px;
>>>>>>>>>> something your broken SHD gets wrong.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> In order for you to have Px simulated by H terminate normally
>>>>>>>>> you must change the behavior of Px away from the behavior that
>>>>>>>>> its x86 code specifies.
>>>>>>>>
>>>>>>>> Your "x86 code" has nothing to do with how my halt decider
>>>>>>>> works; I am using an entirely different simulation method, one
>>>>>>>> that actually works.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> void Px(void (*x)())
>>>>>>>>> {
>>>>>>>>>    (void) H(x, x);
>>>>>>>>>    return;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> Px correctly simulated by H cannot possibly reach past its
>>>>>>>>> machine address of: [00001b3d].
>>>>>>>>>
>>>>>>>>> _Px()
>>>>>>>>> [00001b32] 55         push ebp
>>>>>>>>> [00001b33] 8bec       mov ebp,esp
>>>>>>>>> [00001b35] 8b4508     mov eax,[ebp+08]
>>>>>>>>> [00001b38] 50         push eax      // push address of Px
>>>>>>>>> [00001b39] 8b4d08     mov ecx,[ebp+08]
>>>>>>>>> [00001b3c] 51         push ecx      // push address of Px
>>>>>>>>> [00001b3d] e800faffff call 00001542 // Call H
>>>>>>>>> [00001b42] 83c408     add esp,+08
>>>>>>>>> [00001b45] 5d         pop ebp
>>>>>>>>> [00001b46] c3         ret
>>>>>>>>> Size in bytes:(0021) [00001b46]
>>>>>>>>>
>>>>>>>>> What you are doing is the the same as recognizing that
>>>>>>>>> _Infinite_Loop()
>>>>>>>>> never halts, forcing it to break out of its infinite loop and
>>>>>>>>> jump to
>>>>>>>>> its "ret" instruction
>>>>>>>>>
>>>>>>>>> _Infinite_Loop()
>>>>>>>>> [00001c62] 55         push ebp
>>>>>>>>> [00001c63] 8bec       mov ebp,esp
>>>>>>>>> [00001c65] ebfe       jmp 00001c65
>>>>>>>>> [00001c67] 5d         pop ebp
>>>>>>>>> [00001c68] c3         ret
>>>>>>>>> Size in bytes:(0007) [00001c68]
>>>>>>>>
>>>>>>>> No I am not: there is no infinite loop in Px above; forking the
>>>>>>>> simulation into two branches and returning a different halt
>>>>>>>> decision to each branch is a perfectly valid SHD design; again a
>>>>>>>> design, unlike yours, that actually works.
>>>>>>>
>>>>>>> If you say that Px correctly simulated by H ever reaches its own
>>>>>>> final
>>>>>>> "return" statement and halts you are incorrect.
>>>>>>
>>>>>> Px halts if H is (or is part of) a genuine halt decider.
>>>>>
>>>>> The simulated Px only halts if it reaches its own final state in a
>>>>> finite number of steps of correct simulation. It can't possibly do
>>>>> this.
>>>>
>>>> Nope, a correctly simulated Px will allow it to reach its own final
>>>> state (termination); your H does NOT perform a correct simulation
>>>> because your H is broken.
>>>>
>>>> /Flibble
>>>>
>>>
>>> Strawman deception
>>> Px correctly simulated by H will never reach its own simulated final
>>> state of "return" because Px and H have a pathological relationship to
>>> each other.
>>
>> Nope, there is no pathological relationship between Px and H because
>> Px discards the result of H (i.e. it does not try to do the opposite
>> of the H halting result as per the definition of the Halting Problem).
>>
>
> It seems that you continue to fail to see the nested simulation
>
> 01 void Px(void (*x)())
> 02 {
> 03  (void) H(x, x);
> 04  return;
> 05 }
> 06
> 07 void main()
> 08 {
> 09  H(Px,Px);
> 10 }
>
> *Execution Trace when H never aborts its simulation*
> main() calls H(Px,Px) that simulates Px(Px) at line 09
> *keeps repeating*
>    simulated Px(Px) calls simulated H(Px,Px) that simulates Px(Px) at
> line 03 ...

On 4/21/2023 3:02 PM, Mr Flibble wrote:
> On 21/04/2023 7:36 pm, olcott wrote:
>> On 4/21/2023 12:42 PM, Mr Flibble wrote:
>>> On 21/04/2023 5:41 pm, olcott wrote:
>>>> On 4/21/2023 11:36 AM, Mr Flibble wrote:
>>>>> On 21/04/2023 4:16 pm, olcott wrote:
>>>>>> On 4/21/2023 7:17 AM, Mr Flibble wrote:
>>>>>>> On 20/04/2023 8:20 pm, olcott wrote:
>>>>>>>> On 4/20/2023 2:08 PM, Mr Flibble wrote:
>>>>>>>>> On 20/04/2023 6:49 pm, olcott wrote:
>>>>>>>>>> On 4/20/2023 12:32 PM, Mr Flibble wrote:
>>>>>>>>>>> On 19/04/2023 11:52 pm, olcott wrote:
>>>>>>>>>>>> On 4/19/2023 4:14 PM, Mr Flibble wrote:
>>>>>>>>>>>>> On 19/04/2023 10:10 pm, olcott wrote:
>>>>>>>>>>>>>> On 4/19/2023 3:32 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On 19/04/2023 8:39 pm, olcott wrote:
>>>>>>>>>>>>>>>> On 4/19/2023 1:47 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>> On 18/04/2023 11:39 pm, olcott wrote:
>>>>>>>>>>>>>>>>>> On 4/18/2023 4:55 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>> On 18/04/2023 4:58 pm, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 4/18/2023 6:32 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 4/18/23 1:00 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> A simulating halt decider correctly predicts
>>>>>>>>>>>>>>>>>>>>>> whether or not its
>>>>>>>>>>>>>>>>>>>>>> correctly simulated input can possibly reach its
>>>>>>>>>>>>>>>>>>>>>> own final state and
>>>>>>>>>>>>>>>>>>>>>> halt. It does this by correctly recognizing
>>>>>>>>>>>>>>>>>>>>>> several non-halting behavior
>>>>>>>>>>>>>>>>>>>>>> patterns in a finite number of steps of correct
>>>>>>>>>>>>>>>>>>>>>> simulation. Inputs that
>>>>>>>>>>>>>>>>>>>>>> do terminate are simply simulated until they
>>>>>>>>>>>>>>>>>>>>>> complete.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Except t doesn't o this for the "pathological"
>>>>>>>>>>>>>>>>>>>>> program.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The "Pathological Program" when built on such a
>>>>>>>>>>>>>>>>>>>>> Decider that does give an answer, which you say
>>>>>>>>>>>>>>>>>>>>> will be non-halting, and then "Correctly Simulated"
>>>>>>>>>>>>>>>>>>>>> by giving it representation to a UTM, we see that
>>>>>>>>>>>>>>>>>>>>> the simulation reaches a final state.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Thus, your H was WRONG t make the answer. And the
>>>>>>>>>>>>>>>>>>>>> problem is you have added a pattern that isn't
>>>>>>>>>>>>>>>>>>>>> always non-halting.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> When a simulating halt decider correctly simulates
>>>>>>>>>>>>>>>>>>>>>> N steps of its input
>>>>>>>>>>>>>>>>>>>>>> it derives the exact same N steps that a pure UTM
>>>>>>>>>>>>>>>>>>>>>> would derive because
>>>>>>>>>>>>>>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> But if ISN'T a "UTM" any more, because some of the
>>>>>>>>>>>>>>>>>>>>> features you added have removed essential features
>>>>>>>>>>>>>>>>>>>>> needed for it to be an actual UTM. That you make
>>>>>>>>>>>>>>>>>>>>> this claim shows you don't actually know what a UTM
>>>>>>>>>>>>>>>>>>>>> is.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> This is like saying a NASCAR Racing Car is a Street
>>>>>>>>>>>>>>>>>>>>> Legal vehicle, since it started as one and just had
>>>>>>>>>>>>>>>>>>>>> some extra features axded.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> My reviewers cannot show that any of the extra
>>>>>>>>>>>>>>>>>>>>>> features added to the UTM
>>>>>>>>>>>>>>>>>>>>>> change the behavior of the simulated input for the
>>>>>>>>>>>>>>>>>>>>>> first N steps of simulation:
>>>>>>>>>>>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>>>>>>>>>>>> (b) Matching non-halting behavior patterns doesn't
>>>>>>>>>>>>>>>>>>>>>> change it
>>>>>>>>>>>>>>>>>>>>>> (c) Even aborting the simulation after N steps
>>>>>>>>>>>>>>>>>>>>>> doesn't change the first N steps.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> No one claims that it doesn't correctly reproduce
>>>>>>>>>>>>>>>>>>>>> the first N steps of the behavior, that is a
>>>>>>>>>>>>>>>>>>>>> Strawman argumen.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Because of all this we can know that the first N
>>>>>>>>>>>>>>>>>>>>>> steps of input D
>>>>>>>>>>>>>>>>>>>>>> simulated by simulating halt decider H are the
>>>>>>>>>>>>>>>>>>>>>> actual behavior that D
>>>>>>>>>>>>>>>>>>>>>> presents to H for these same N steps.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *computation that halts*… “the Turing machine will
>>>>>>>>>>>>>>>>>>>>>> halt whenever it enters a final state”
>>>>>>>>>>>>>>>>>>>>>> (Linz:1990:234)rrr
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Right, so we are concerned about the behavior of
>>>>>>>>>>>>>>>>>>>>> the ACTUAL machine, not a partial simulation of it.
>>>>>>>>>>>>>>>>>>>>> H(D,D) returns non-halting, but D(D) Halts, so the
>>>>>>>>>>>>>>>>>>>>> answer is wrong.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> When we see (after N steps) that D correctly
>>>>>>>>>>>>>>>>>>>>>> simulated by H cannot
>>>>>>>>>>>>>>>>>>>>>> possibly reach its simulated final state in any
>>>>>>>>>>>>>>>>>>>>>> finite number of steps
>>>>>>>>>>>>>>>>>>>>>> of correct simulation then we have conclusive
>>>>>>>>>>>>>>>>>>>>>> proof that D presents non-
>>>>>>>>>>>>>>>>>>>>>> halting behavior to H.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> But it isn't "Correctly Simulated by H"
>>>>>>>>>>>>>>>>>>>> You agreed that the first N steps are correctly
>>>>>>>>>>>>>>>>>>>> simulated.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> It turns out that the non-halting behavior pattern
>>>>>>>>>>>>>>>>>>>> is correctly
>>>>>>>>>>>>>>>>>>>> recognized in the first N steps.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Your assumption that a program that calls H is
>>>>>>>>>>>>>>>>>>> non-halting is erroneous:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> My new paper anchors its ideas in actual Turing
>>>>>>>>>>>>>>>>>> machines so it is
>>>>>>>>>>>>>>>>>> unequivocal. The first two pages re only about the
>>>>>>>>>>>>>>>>>> Linz Turing
>>>>>>>>>>>>>>>>>> machine based proof.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The H/D material is now on a single page and all
>>>>>>>>>>>>>>>>>> reference
>>>>>>>>>>>>>>>>>> to the x86 language has been stripped and replaced with
>>>>>>>>>>>>>>>>>> analysis entirely in C.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> With this new paper even Richard admits that the first
>>>>>>>>>>>>>>>>>> N steps
>>>>>>>>>>>>>>>>>> UTM based simulated by a simulating halt decider are
>>>>>>>>>>>>>>>>>> necessarily the
>>>>>>>>>>>>>>>>>> actual behavior of these N steps.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *Simulating (partial) Halt Deciders Defeat the Halting
>>>>>>>>>>>>>>>>>> Problem Proofs*
>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/369971402_Simulating_partial_Halt_Deciders_Defeat_the_Halting_Problem_Proofs
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> void Px(void (*x)())
>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>      (void) H(x, x);
>>>>>>>>>>>>>>>>>>>      return;
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Px halts (it discards the result that H returns);
>>>>>>>>>>>>>>>>>>> your decider thinks that Px is non-halting which is
>>>>>>>>>>>>>>>>>>> an obvious error due to a design flaw in the
>>>>>>>>>>>>>>>>>>> architecture of your decider.  Only the Flibble
>>>>>>>>>>>>>>>>>>> Signaling Simulating Halt Decider (SSHD) correctly
>>>>>>>>>>>>>>>>>>> handles this case.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Nope. For H to be a halt decider it must return a halt
>>>>>>>>>>>>>>>>> decision to its caller in finite time
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Although H must always return to some caller H is not
>>>>>>>>>>>>>>>> allowed to return
>>>>>>>>>>>>>>>> to any caller that essentially calls H in infinite
>>>>>>>>>>>>>>>> recursion.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The Flibble Signaling Simulating Halt Decider (SSHD) does
>>>>>>>>>>>>>>> not have any infinite recursion thereby proving that
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It overrode that behavior that was specified by the
>>>>>>>>>>>>>> machine code for Px.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope. You SHD is not a halt decider as
>>>>>>>>>>>>
>>>>>>>>>>>> I was not even talking about my SHD, I was talking about how
>>>>>>>>>>>> your program does its simulation incorrectly.
>>>>>>>>>>>
>>>>>>>>>>> My SSHD does not do its simulation incorrectly: it does its
>>>>>>>>>>> simulation just like I have defined it as evidenced by the
>>>>>>>>>>> fact that it returns a correct halting decision for Px;
>>>>>>>>>>> something your broken SHD gets wrong.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> In order for you to have Px simulated by H terminate normally
>>>>>>>>>> you must change the behavior of Px away from the behavior that
>>>>>>>>>> its x86 code specifies.
>>>>>>>>>
>>>>>>>>> Your "x86 code" has nothing to do with how my halt decider
>>>>>>>>> works; I am using an entirely different simulation method, one
>>>>>>>>> that actually works.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> void Px(void (*x)())
>>>>>>>>>> {
>>>>>>>>>>    (void) H(x, x);
>>>>>>>>>>    return;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> Px correctly simulated by H cannot possibly reach past its
>>>>>>>>>> machine address of: [00001b3d].
>>>>>>>>>>
>>>>>>>>>> _Px()
>>>>>>>>>> [00001b32] 55         push ebp
>>>>>>>>>> [00001b33] 8bec       mov ebp,esp
>>>>>>>>>> [00001b35] 8b4508     mov eax,[ebp+08]
>>>>>>>>>> [00001b38] 50         push eax      // push address of Px
>>>>>>>>>> [00001b39] 8b4d08     mov ecx,[ebp+08]
>>>>>>>>>> [00001b3c] 51         push ecx      // push address of Px
>>>>>>>>>> [00001b3d] e800faffff call 00001542 // Call H
>>>>>>>>>> [00001b42] 83c408     add esp,+08
>>>>>>>>>> [00001b45] 5d         pop ebp
>>>>>>>>>> [00001b46] c3         ret
>>>>>>>>>> Size in bytes:(0021) [00001b46]
>>>>>>>>>>
>>>>>>>>>> What you are doing is the the same as recognizing that
>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>> never halts, forcing it to break out of its infinite loop and
>>>>>>>>>> jump to
>>>>>>>>>> its "ret" instruction
>>>>>>>>>>
>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>> [00001c62] 55         push ebp
>>>>>>>>>> [00001c63] 8bec       mov ebp,esp
>>>>>>>>>> [00001c65] ebfe       jmp 00001c65
>>>>>>>>>> [00001c67] 5d         pop ebp
>>>>>>>>>> [00001c68] c3         ret
>>>>>>>>>> Size in bytes:(0007) [00001c68]
>>>>>>>>>
>>>>>>>>> No I am not: there is no infinite loop in Px above; forking the
>>>>>>>>> simulation into two branches and returning a different halt
>>>>>>>>> decision to each branch is a perfectly valid SHD design; again
>>>>>>>>> a design, unlike yours, that actually works.
>>>>>>>>
>>>>>>>> If you say that Px correctly simulated by H ever reaches its own
>>>>>>>> final
>>>>>>>> "return" statement and halts you are incorrect.
>>>>>>>
>>>>>>> Px halts if H is (or is part of) a genuine halt decider.
>>>>>>
>>>>>> The simulated Px only halts if it reaches its own final state in a
>>>>>> finite number of steps of correct simulation. It can't possibly do
>>>>>> this.
>>>>>
>>>>> Nope, a correctly simulated Px will allow it to reach its own final
>>>>> state (termination); your H does NOT perform a correct simulation
>>>>> because your H is broken.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> Strawman deception
>>>> Px correctly simulated by H will never reach its own simulated final
>>>> state of "return" because Px and H have a pathological relationship to
>>>> each other.
>>>
>>> Nope, there is no pathological relationship between Px and H because
>>> Px discards the result of H (i.e. it does not try to do the opposite
>>> of the H halting result as per the definition of the Halting Problem).
>>>
>>
>> It seems that you continue to fail to see the nested simulation
>>
>> 01 void Px(void (*x)())
>> 02 {
>> 03  (void) H(x, x);
>> 04  return;
>> 05 }
>> 06
>> 07 void main()
>> 08 {
>> 09  H(Px,Px);
>> 10 }
>>
>> *Execution Trace when H never aborts its simulation*
>> main() calls H(Px,Px) that simulates Px(Px) at line 09
>> *keeps repeating*
>>     simulated Px(Px) calls simulated H(Px,Px) that simulates Px(Px) at
>> line 03 ...
>
> "nested simulation" (recursion) is a property of your broken halt
> decider

On 21/04/2023 10:06 pm, olcott wrote:
> On 4/21/2023 3:02 PM, Mr Flibble wrote:
>> On 21/04/2023 7:36 pm, olcott wrote:
>>> On 4/21/2023 12:42 PM, Mr Flibble wrote:
>>>> On 21/04/2023 5:41 pm, olcott wrote:
>>>>> On 4/21/2023 11:36 AM, Mr Flibble wrote:
>>>>>> On 21/04/2023 4:16 pm, olcott wrote:
>>>>>>> On 4/21/2023 7:17 AM, Mr Flibble wrote:
>>>>>>>> On 20/04/2023 8:20 pm, olcott wrote:
>>>>>>>>> On 4/20/2023 2:08 PM, Mr Flibble wrote:
>>>>>>>>>> On 20/04/2023 6:49 pm, olcott wrote:
>>>>>>>>>>> On 4/20/2023 12:32 PM, Mr Flibble wrote:
>>>>>>>>>>>> On 19/04/2023 11:52 pm, olcott wrote:
>>>>>>>>>>>>> On 4/19/2023 4:14 PM, Mr Flibble wrote:
>>>>>>>>>>>>>> On 19/04/2023 10:10 pm, olcott wrote:
>>>>>>>>>>>>>>> On 4/19/2023 3:32 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>> On 19/04/2023 8:39 pm, olcott wrote:
>>>>>>>>>>>>>>>>> On 4/19/2023 1:47 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>> On 18/04/2023 11:39 pm, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 4/18/2023 4:55 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>> On 18/04/2023 4:58 pm, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 4/18/2023 6:32 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 4/18/23 1:00 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> A simulating halt decider correctly predicts
>>>>>>>>>>>>>>>>>>>>>>> whether or not its
>>>>>>>>>>>>>>>>>>>>>>> correctly simulated input can possibly reach its
>>>>>>>>>>>>>>>>>>>>>>> own final state and
>>>>>>>>>>>>>>>>>>>>>>> halt. It does this by correctly recognizing
>>>>>>>>>>>>>>>>>>>>>>> several non-halting behavior
>>>>>>>>>>>>>>>>>>>>>>> patterns in a finite number of steps of correct
>>>>>>>>>>>>>>>>>>>>>>> simulation. Inputs that
>>>>>>>>>>>>>>>>>>>>>>> do terminate are simply simulated until they
>>>>>>>>>>>>>>>>>>>>>>> complete.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Except t doesn't o this for the "pathological"
>>>>>>>>>>>>>>>>>>>>>> program.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The "Pathological Program" when built on such a
>>>>>>>>>>>>>>>>>>>>>> Decider that does give an answer, which you say
>>>>>>>>>>>>>>>>>>>>>> will be non-halting, and then "Correctly
>>>>>>>>>>>>>>>>>>>>>> Simulated" by giving it representation to a UTM,
>>>>>>>>>>>>>>>>>>>>>> we see that the simulation reaches a final state.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Thus, your H was WRONG t make the answer. And the
>>>>>>>>>>>>>>>>>>>>>> problem is you have added a pattern that isn't
>>>>>>>>>>>>>>>>>>>>>> always non-halting.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> When a simulating halt decider correctly
>>>>>>>>>>>>>>>>>>>>>>> simulates N steps of its input
>>>>>>>>>>>>>>>>>>>>>>> it derives the exact same N steps that a pure UTM
>>>>>>>>>>>>>>>>>>>>>>> would derive because
>>>>>>>>>>>>>>>>>>>>>>> it is itself a UTM with extra features.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> But if ISN'T a "UTM" any more, because some of the
>>>>>>>>>>>>>>>>>>>>>> features you added have removed essential features
>>>>>>>>>>>>>>>>>>>>>> needed for it to be an actual UTM. That you make
>>>>>>>>>>>>>>>>>>>>>> this claim shows you don't actually know what a
>>>>>>>>>>>>>>>>>>>>>> UTM is.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> This is like saying a NASCAR Racing Car is a
>>>>>>>>>>>>>>>>>>>>>> Street Legal vehicle, since it started as one and
>>>>>>>>>>>>>>>>>>>>>> just had some extra features axded.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> My reviewers cannot show that any of the extra
>>>>>>>>>>>>>>>>>>>>>>> features added to the UTM
>>>>>>>>>>>>>>>>>>>>>>> change the behavior of the simulated input for
>>>>>>>>>>>>>>>>>>>>>>> the first N steps of simulation:
>>>>>>>>>>>>>>>>>>>>>>> (a) Watching the behavior doesn't change it.
>>>>>>>>>>>>>>>>>>>>>>> (b) Matching non-halting behavior patterns
>>>>>>>>>>>>>>>>>>>>>>> doesn't change it
>>>>>>>>>>>>>>>>>>>>>>> (c) Even aborting the simulation after N steps
>>>>>>>>>>>>>>>>>>>>>>> doesn't change the first N steps.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> No one claims that it doesn't correctly reproduce
>>>>>>>>>>>>>>>>>>>>>> the first N steps of the behavior, that is a
>>>>>>>>>>>>>>>>>>>>>> Strawman argumen.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Because of all this we can know that the first N
>>>>>>>>>>>>>>>>>>>>>>> steps of input D
>>>>>>>>>>>>>>>>>>>>>>> simulated by simulating halt decider H are the
>>>>>>>>>>>>>>>>>>>>>>> actual behavior that D
>>>>>>>>>>>>>>>>>>>>>>> presents to H for these same N steps.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *computation that halts*… “the Turing machine
>>>>>>>>>>>>>>>>>>>>>>> will halt whenever it enters a final state”
>>>>>>>>>>>>>>>>>>>>>>> (Linz:1990:234)rrr
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Right, so we are concerned about the behavior of
>>>>>>>>>>>>>>>>>>>>>> the ACTUAL machine, not a partial simulation of it.
>>>>>>>>>>>>>>>>>>>>>> H(D,D) returns non-halting, but D(D) Halts, so the
>>>>>>>>>>>>>>>>>>>>>> answer is wrong.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> When we see (after N steps) that D correctly
>>>>>>>>>>>>>>>>>>>>>>> simulated by H cannot
>>>>>>>>>>>>>>>>>>>>>>> possibly reach its simulated final state in any
>>>>>>>>>>>>>>>>>>>>>>> finite number of steps
>>>>>>>>>>>>>>>>>>>>>>> of correct simulation then we have conclusive
>>>>>>>>>>>>>>>>>>>>>>> proof that D presents non-
>>>>>>>>>>>>>>>>>>>>>>> halting behavior to H.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> But it isn't "Correctly Simulated by H"
>>>>>>>>>>>>>>>>>>>>> You agreed that the first N steps are correctly
>>>>>>>>>>>>>>>>>>>>> simulated.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> It turns out that the non-halting behavior pattern
>>>>>>>>>>>>>>>>>>>>> is correctly
>>>>>>>>>>>>>>>>>>>>> recognized in the first N steps.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Your assumption that a program that calls H is
>>>>>>>>>>>>>>>>>>>> non-halting is erroneous:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> My new paper anchors its ideas in actual Turing
>>>>>>>>>>>>>>>>>>> machines so it is
>>>>>>>>>>>>>>>>>>> unequivocal. The first two pages re only about the
>>>>>>>>>>>>>>>>>>> Linz Turing
>>>>>>>>>>>>>>>>>>> machine based proof.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The H/D material is now on a single page and all
>>>>>>>>>>>>>>>>>>> reference
>>>>>>>>>>>>>>>>>>> to the x86 language has been stripped and replaced with
>>>>>>>>>>>>>>>>>>> analysis entirely in C.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> With this new paper even Richard admits that the
>>>>>>>>>>>>>>>>>>> first N steps
>>>>>>>>>>>>>>>>>>> UTM based simulated by a simulating halt decider are
>>>>>>>>>>>>>>>>>>> necessarily the
>>>>>>>>>>>>>>>>>>> actual behavior of these N steps.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *Simulating (partial) Halt Deciders Defeat the
>>>>>>>>>>>>>>>>>>> Halting Problem Proofs*
>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/369971402_Simulating_partial_Halt_Deciders_Defeat_the_Halting_Problem_Proofs
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> void Px(void (*x)())
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>      (void) H(x, x);
>>>>>>>>>>>>>>>>>>>>      return;
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Px halts (it discards the result that H returns);
>>>>>>>>>>>>>>>>>>>> your decider thinks that Px is non-halting which is
>>>>>>>>>>>>>>>>>>>> an obvious error due to a design flaw in the
>>>>>>>>>>>>>>>>>>>> architecture of your decider.  Only the Flibble
>>>>>>>>>>>>>>>>>>>> Signaling Simulating Halt Decider (SSHD) correctly
>>>>>>>>>>>>>>>>>>>> handles this case.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Nope. For H to be a halt decider it must return a halt
>>>>>>>>>>>>>>>>>> decision to its caller in finite time
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Although H must always return to some caller H is not
>>>>>>>>>>>>>>>>> allowed to return
>>>>>>>>>>>>>>>>> to any caller that essentially calls H in infinite
>>>>>>>>>>>>>>>>> recursion.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The Flibble Signaling Simulating Halt Decider (SSHD)
>>>>>>>>>>>>>>>> does not have any infinite recursion thereby proving that
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It overrode that behavior that was specified by the
>>>>>>>>>>>>>>> machine code for Px.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Nope. You SHD is not a halt decider as
>>>>>>>>>>>>>
>>>>>>>>>>>>> I was not even talking about my SHD, I was talking about
>>>>>>>>>>>>> how your program does its simulation incorrectly.
>>>>>>>>>>>>
>>>>>>>>>>>> My SSHD does not do its simulation incorrectly: it does its
>>>>>>>>>>>> simulation just like I have defined it as evidenced by the
>>>>>>>>>>>> fact that it returns a correct halting decision for Px;
>>>>>>>>>>>> something your broken SHD gets wrong.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> In order for you to have Px simulated by H terminate normally
>>>>>>>>>>> you must change the behavior of Px away from the behavior
>>>>>>>>>>> that its x86 code specifies.
>>>>>>>>>>
>>>>>>>>>> Your "x86 code" has nothing to do with how my halt decider
>>>>>>>>>> works; I am using an entirely different simulation method, one
>>>>>>>>>> that actually works.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> void Px(void (*x)())
>>>>>>>>>>> {
>>>>>>>>>>>    (void) H(x, x);
>>>>>>>>>>>    return;
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> Px correctly simulated by H cannot possibly reach past its
>>>>>>>>>>> machine address of: [00001b3d].
>>>>>>>>>>>
>>>>>>>>>>> _Px()
>>>>>>>>>>> [00001b32] 55         push ebp
>>>>>>>>>>> [00001b33] 8bec       mov ebp,esp
>>>>>>>>>>> [00001b35] 8b4508     mov eax,[ebp+08]
>>>>>>>>>>> [00001b38] 50         push eax      // push address of Px
>>>>>>>>>>> [00001b39] 8b4d08     mov ecx,[ebp+08]
>>>>>>>>>>> [00001b3c] 51         push ecx      // push address of Px
>>>>>>>>>>> [00001b3d] e800faffff call 00001542 // Call H
>>>>>>>>>>> [00001b42] 83c408     add esp,+08
>>>>>>>>>>> [00001b45] 5d         pop ebp
>>>>>>>>>>> [00001b46] c3         ret
>>>>>>>>>>> Size in bytes:(0021) [00001b46]
>>>>>>>>>>>
>>>>>>>>>>> What you are doing is the the same as recognizing that
>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>> never halts, forcing it to break out of its infinite loop and
>>>>>>>>>>> jump to
>>>>>>>>>>> its "ret" instruction
>>>>>>>>>>>
>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>> [00001c62] 55         push ebp
>>>>>>>>>>> [00001c63] 8bec       mov ebp,esp
>>>>>>>>>>> [00001c65] ebfe       jmp 00001c65
>>>>>>>>>>> [00001c67] 5d         pop ebp
>>>>>>>>>>> [00001c68] c3         ret
>>>>>>>>>>> Size in bytes:(0007) [00001c68]
>>>>>>>>>>
>>>>>>>>>> No I am not: there is no infinite loop in Px above; forking
>>>>>>>>>> the simulation into two branches and returning a different
>>>>>>>>>> halt decision to each branch is a perfectly valid SHD design;
>>>>>>>>>> again a design, unlike yours, that actually works.
>>>>>>>>>
>>>>>>>>> If you say that Px correctly simulated by H ever reaches its
>>>>>>>>> own final
>>>>>>>>> "return" statement and halts you are incorrect.
>>>>>>>>
>>>>>>>> Px halts if H is (or is part of) a genuine halt decider.
>>>>>>>
>>>>>>> The simulated Px only halts if it reaches its own final state in a
>>>>>>> finite number of steps of correct simulation. It can't possibly
>>>>>>> do this.
>>>>>>
>>>>>> Nope, a correctly simulated Px will allow it to reach its own
>>>>>> final state (termination); your H does NOT perform a correct
>>>>>> simulation because your H is broken.
>>>>>>
>>>>>> /Flibble
>>>>>>
>>>>>
>>>>> Strawman deception
>>>>> Px correctly simulated by H will never reach its own simulated final
>>>>> state of "return" because Px and H have a pathological relationship to
>>>>> each other.
>>>>
>>>> Nope, there is no pathological relationship between Px and H because
>>>> Px discards the result of H (i.e. it does not try to do the opposite
>>>> of the H halting result as per the definition of the Halting Problem).
>>>>
>>>
>>> It seems that you continue to fail to see the nested simulation
>>>
>>> 01 void Px(void (*x)())
>>> 02 {
>>> 03  (void) H(x, x);
>>> 04  return;
>>> 05 }
>>> 06
>>> 07 void main()
>>> 08 {
>>> 09  H(Px,Px);
>>> 10 }
>>>
>>> *Execution Trace when H never aborts its simulation*
>>> main() calls H(Px,Px) that simulates Px(Px) at line 09
>>> *keeps repeating*
>>>     simulated Px(Px) calls simulated H(Px,Px) that simulates Px(Px)
>>> at line 03 ...
>>
>> "nested simulation" (recursion) is a property of your broken halt decider
>
> Nested simulation is inherent when any simulating halt decider is
> applied to any of the conventional halting problem counter-example
> inputs. That you may fail to comprehend this is not my mistake.