On 1/22/22 4:25 PM, olcott wrote:
> On 1/22/2022 3:20 PM, Richard Damon wrote:
>>
>> On 1/22/22 3:42 PM, olcott wrote:
>>> On 1/22/2022 2:27 PM, Richard Damon wrote:
>>>> On 1/22/22 1:53 PM, olcott wrote:
>>>>> On 1/22/2022 12:42 PM, Richard Damon wrote:
>>>>>> On 1/22/22 1:26 PM, olcott wrote:
>>>>>>> On 1/22/2022 12:21 PM, Richard Damon wrote:
>>>>>>>> On 1/22/22 12:53 PM, olcott wrote:
>>>>>>>>> On 1/22/2022 11:33 AM, Richard Damon wrote:
>>>>>>>>>> On 1/22/22 12:19 PM, olcott wrote:
>>>>>>>>>>> On 1/22/2022 11:13 AM, Richard Damon wrote:
>>>>>>>>>>>> On 1/22/22 11:47 AM, olcott wrote:
>>>>>>>>>>>>> On 1/22/2022 10:39 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 1/22/22 11:29 AM, olcott wrote:
>>>>>>>>>>>>>>> On 1/22/2022 10:23 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 1/22/22 10:48 AM, olcott wrote:
>>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>>>>>>> simulation (V3)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Take FIFTY TWO, I think you are stuck in an apparent
>>>>>>>>>>>>>>>> infinite loop.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You keep on repeating the same basic mistakes.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> We define Linz H to base its halt status decision on
>>>>>>>>>>>>>>>>> the behavior of its pure simulation of N steps of its
>>>>>>>>>>>>>>>>> input. N is either the number of steps that it takes
>>>>>>>>>>>>>>>>> for its simulated input to reach its final state or the
>>>>>>>>>>>>>>>>> number of steps required for H to match an infinite
>>>>>>>>>>>>>>>>> behavior pattern proving that the simulated input would
>>>>>>>>>>>>>>>>> never reach its own final state. In this case H aborts
>>>>>>>>>>>>>>>>> the simulation of this input and transitions to H.qn.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Such a pattern NOT existing for the <H^> <H^> pattern,
>>>>>>>>>>>>>>>> thus your H can't correctly abort and becomes
>>>>>>>>>>>>>>>> non-answering and thus FAILS to be a decider.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The non-existance has been proven and you have ignored
>>>>>>>>>>>>>>>> that proof, showing you have no counter for the proof.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If you want to claim such a pattern exists, you MUST
>>>>>>>>>>>>>>>> provide it or accept that your logic is just plain
>>>>>>>>>>>>>>>> flawed as you are claiming the existance of something
>>>>>>>>>>>>>>>> that is impossible.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> In effect, you are saying that if you have a halt
>>>>>>>>>>>>>>>> decider for you halt decider to use, you can write a
>>>>>>>>>>>>>>>> halt decider.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The following simplifies the syntax for the definition
>>>>>>>>>>>>>>>>> of the Linz Turing machine Ĥ, it is now a single
>>>>>>>>>>>>>>>>> machine with a single start state. A copy of Linz H is
>>>>>>>>>>>>>>>>> embedded at Ĥ.qx.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Because it is known that the UTM simulation of a
>>>>>>>>>>>>>>>>> machine is computationally equivalent to the direct
>>>>>>>>>>>>>>>>> execution of this same machine H can always form its
>>>>>>>>>>>>>>>>> halt status decision on the basis of what the behavior
>>>>>>>>>>>>>>>>> of the UTM simulation of its inputs would be.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has embedded_H simulate ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>> these steps would keep repeating:
>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But only if H never aborts, if H does abort, then the
>>>>>>>>>>>>>>>> pattern is broken.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> YOU ARE EITHER TOO IGNORANT OR DISHONEST TO ACKNOWLEDGE
>>>>>>>>>>>>>>> THE TRUTH OF THIS:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The fact that there are no finite number of steps that
>>>>>>>>>>>>>>> the simulated input to embedded_H would ever reach its
>>>>>>>>>>>>>>> final state conclusively proves that embedded_H is
>>>>>>>>>>>>>>> correct to abort its simulation of this input and
>>>>>>>>>>>>>>> transition to Ĥ.qn.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The problem is that any H that aborts after a finite
>>>>>>>>>>>>>> number of steps, gives the wrong answer because it only
>>>>>>>>>>>>>> looked to see if the input doesn't halt at some specific
>>>>>>>>>>>>>> finite number.
>>>>>>>>>>>>>
>>>>>>>>>>>>> OK IGNORANT it is. When there exists no finite (or
>>>>>>>>>>>>> infinite) number of steps such that the simulated input to
>>>>>>>>>>>>> embedded_H reaches its final state then we know that this
>>>>>>>>>>>>> simulated input does not halt.
>>>>>>>>>>>>
>>>>>>>>>>>> And the only case when that happens is when H does not abort
>>>>>>>>>>>> its simulation,
>>>>>>>>>>>>
>>>>>>>>>>> WRONG !!!  That happens in every possible case. The simulated
>>>>>>>>>>> input to embedded_H cannot possibly ever reach its final
>>>>>>>>>>> state NO MATTER WHAT !!!
>>>>>>>>>>
>>>>>>>>>> But if H/embedded_H aborts its simulation, it doesn't matter
>>>>>>>>>> if IT sees it or not, as it isn't then a UTM any longer.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It remains true (invariant) that the simulated input to
>>>>>>>>> embedded_H cannot possibly ever reach its final state no matter
>>>>>>>>> what embedded_H does, thus conclusively proving that this input
>>>>>>>>> never halts.
>>>>>>>>>
>>>>>>>>>> If H aborts its simulation and goes to H.Qn then H^ applied to
>>>>>>>>>> <H^> and the UTM Simulation of <H^> <H^> will go to H^.Qn and
>>>>>>>>>> Halt.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Because a halt decider is a decider embedded_H is only
>>>>>>>>> accountable for computing the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or
>>>>>>>>> Ĥ.qn on the basis of the behavior specified by these inputs.
>>>>>>>>> embedded_H is not accountable for the behavior of the
>>>>>>>>> computation that it is contained within: Ĥ applied to ⟨Ĥ⟩
>>>>>>>>> because this is not an actual input to embedded_H.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Right, and if H(<H^>,<H^>) -> H.Qn then the proper simulation by
>>>>>>>> the computation UTM(<H^>,<H^>) will show that H^ also go to
>>>>>>>> H^.Qn and Halt.
>>>>>>>>
>>>>>>>> THAT is the defined behavior of the actual input to H.
>>>>>>>>
>>>>>>>
>>>>>>> You can define that a cat is a dog, yet the actual simulated
>>>>>>> input to embedded_H cannot possibly reach its final state NO
>>>>>>> MATTER WHAT.
>>>>>>
>>>>>> But it does. embeddd_H can't simuate to that point,
>>>>>
>>>>> If the simulated input cannot possibly every reach its final state
>>>>> no matter what embedded_H does then this simulated input is
>>>>> correctly determined to meet the Linz definition of never halting.
>>>>>
>>>>
>>>> Except that the simulated input DOES reach its final state if
>>>> H/embeded_H goes to H.Qn.
>>>
>>> Before embedded_H transitions to Ĥ.qn it has already aborted its
>>> simulated input making it utterly impossible for any aspect of this
>>> simulated input to do anything at all.
>>
>> Then you are just talking POOP and not halting.
>>
>
> It is simply beyond your intellectual capacity:
>
> This is true for infinite loops, infinite recursion, infinitely nested
> simulation and all other non halting inputs:
>
> When-so-ever any simulated input to any simulating halt decider would
> never reach the final state of this simulated input in any finite number
> of steps it is always correct for the simulating halt decider to abort
> its simulation and transition to its reject state.
>

Can you PROVE that statement, or is this just one of your false 'self
evident truth'. Does the proof include the posibility that the input
includes a copy of the decider?

The problem is that IF the simulating halt decider does abort its input
based on some condition, then it is no longer a source of truth for the
halting status of that input.

It turns out that for H^, if H does abort its simulation, then it turns
out that an actual simulation of the input proves that it will halt.

>> Remember, the definition of Halting is based on what a UTM does with
>> the exact same input, and the UTM WON'T (in fact CAN'T) abort the
>> simulation at that point but continues on, and that H^ will continue
>> on to use a copy of H that will do that exact same simulation and
>> abort its simulation (but not the running of its 'caller'), and
>> transition to H.Qn which means H^ goes to H^.Qn and Halts.
>>
>> FAIL.
>>
>>
>>
>>>
>>> It is just like unplugging your computer, zero more steps are executed.
>>>
>>
>> Except Halting isn't based on what a particular copy does, but what
>> any copy would do if allowed to run.
>>
>> FAIL
>>
>> Seems to me to be just more POOP.
>>
>> CLEANUP ON AISLE 52, someone has left POOP all over the floor.
>
>