Halting problem undecidability and infinitely nested simulation (V3)

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.

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 ⟨Ĥ⟩ ⟨Ĥ⟩...

computation that halts … the Turing machine will halt whenever it enters
a final state. (Linz:1990:234)

This shows that the simulated input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ would never
reach its final state conclusively proving that this simulated input
never halts. This enables embedded_H to abort the simulation of its
input and correctly transition to Ĥ.qn.

if embedded_H does correctly recognize an infinitely repeating behavior
pattern in the behavior of its simulated input: ⟨Ĥ⟩ applied to ⟨Ĥ⟩ then
embedded_H is necessarily correct to abort the simulation of its input
and transition to Ĥ.qn.

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.

Halting problem undecidability and infinitely nested simulation (V3)

https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3

--
Copyright 2021 Pete Olcott "Talent hits a target no one else can hit;
Genius hits a target no one else can see." Arthur Schopenhauer

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.

>>
>> computation that halts … the Turing machine will halt whenever it
>> enters a final state. (Linz:1990:234)
>>
>> This shows that the simulated input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ would never
>> reach its final state conclusively proving that this simulated input
>> never halts. This enables embedded_H to abort the simulation of its
>> input and correctly transition to Ĥ.qn.
>
> No, it doesn't, it shows that the H^ built on an H that doesn't abort
> will not halt, but that H doesn't answer. If H does abort, and thus can
> give the answer, the logic is incorrect.
>
> FAIL.
>
>>
>> if embedded_H does correctly recognize an infinitely repeating
>> behavior pattern in the behavior of its simulated input: ⟨Ĥ⟩ applied
>> to ⟨Ĥ⟩ then embedded_H is necessarily correct to abort the simulation
>> of its input and transition to Ĥ.qn.
>
> Which it can not do, as shown to be impossible.
>
>>
>> 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.
>>
>
> As mentioned before, for the input <H^> <H^> when H^ is based on the H
> that claims to correctly go to H.Qn, then UTM(<H^>,<H^>) is shown to
> also go to H^.Qn and Halt, so the input that H IS accountable for
> doesn't match the behavior that H assigns to it.
>
> FAIL.
>
>>
>>
>>
>> Halting problem undecidability and infinitely nested simulation (V3)
>>
>> https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3
>>
>>
>
> You are still using Fairy Dust powered Unicorns as the basis of your proof.
>
> FAIL.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

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 !!!

Halting problem undecidability and infinitely nested simulation (V3)

https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

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.

> THAT is what matters, and shows that H was wromg.
>
> You keep on believing a false source of 'truth'.
>
> FAIL.
>>
>>
>>
>> Halting problem undecidability and infinitely nested simulation (V3)
>>
>> https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3
>>
>>
>

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

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.
>

Andrew Wiles, Terence Tao, Thomas Hales, Jill Pipher, Ken Ribet, John Stillwell need to go to their affiliated University student newspaper and publish their apology for teaching the brainwashed propaganda that a slant cut in single cone is a ellipse when it is in fact a Oval, never the ellipse, for a single cone has only 1 axis of symmetry.

AP's Proof-Ellipse was never a Conic Section // Math proof series, book 1 Kindle Edition
by Archimedes Plutonium (Author)

Ever since Ancient Greek Times it was thought the slant cut into a cone is the ellipse. That was false. For the slant cut in every cone is a Oval, never an Ellipse. This book is a proof that the slant cut is a oval, never the ellipse. A slant cut into the Cylinder is in fact a ellipse, but never in a cone.

Product details
• ASIN ‏ : ‎ B07PLSDQWC
• Publication date ‏ : ‎ March 11, 2019
• Language ‏ : ‎ English
• File size ‏ : ‎ 1621 KB
• Text-to-Speech ‏ : ‎ Enabled
• Enhanced typesetting ‏ : ‎ Enabled
• X-Ray ‏ : ‎ Not Enabled
• Word Wise ‏ : ‎ Not Enabled
• Print length ‏ : ‎ 20 pages
• Lending ‏ : ‎ Enabled
•
•

#11-2, 11th published book

World's First Geometry Proof of Fundamental Theorem of Calculus// Math proof series, book 2 Kindle Edition
by Archimedes Plutonium (Author)

Last revision was 15Dec2021. This is AP's 11th published book of science.
Preface:
Actually my title is too modest, for the proof that lies within this book makes it the World's First Valid Proof of Fundamental Theorem of Calculus, for in my modesty, I just wanted to emphasis that calculus was geometry and needed a geometry proof. Not being modest, there has never been a valid proof of FTC until AP's 2015 proof. This also implies that only a geometry proof of FTC constitutes a valid proof of FTC.

Calculus needs a geometry proof of Fundamental Theorem of Calculus. But none could ever be obtained in Old Math so long as they had a huge mass of mistakes, errors, fakes and con-artist trickery such as the "limit analysis". And very surprising that most math professors cannot tell the difference between a "proving something" and that of "analyzing something". As if an analysis is the same as a proof. We often analyze various things each and every day, but few if none of us consider a analysis as a proof. Yet that is what happened in the science of mathematics where they took an analysis and elevated it to the stature of being a proof, when it was never a proof.

To give a Geometry Proof of Fundamental Theorem of Calculus requires math be cleaned-up and cleaned-out of most of math's mistakes and errors. So in a sense, a Geometry FTC proof is a exercise in Consistency of all of Mathematics. In order to prove a FTC geometry proof, requires throwing out the error filled mess of Old Math. Can the Reals be the true numbers of mathematics if the Reals cannot deliver a Geometry proof of FTC? Can the functions that are not polynomial functions allow us to give a Geometry proof of FTC? Can a Coordinate System in 2D have 4 quadrants and still give a Geometry proof of FTC? Can a equation of mathematics with a number that is _not a positive decimal Grid Number_ all alone on the right side of the equation, at all times, allow us to give a Geometry proof of the FTC?

Cover Picture: Is my hand written, one page geometry proof of the Fundamental Theorem of Calculus, the world's first geometry proof of FTC, 2013-2015, by AP.

Product details
ASIN ‏ : ‎ B07PQTNHMY
Publication date ‏ : ‎ March 14, 2019
Language ‏ : ‎ English
File size ‏ : ‎ 1309 KB
Text-to-Speech ‏ : ‎ Enabled
Screen Reader ‏ : ‎ Supported
Enhanced typesetting ‏ : ‎ Enabled
X-Ray ‏ : ‎ Not Enabled
Word Wise ‏ : ‎ Not Enabled
Print length ‏ : ‎ 154 pages
Lending ‏ : ‎ Enabled
Amazon Best Sellers Rank: #128,729 Paid in Kindle Store (See Top 100 Paid in Kindle Store)
#2 in 45-Minute Science & Math Short Reads
#134 in Calculus (Books)
#20 in Calculus (Kindle Store)

#11-3, 24th published book

World's First Proof of Kepler Packing Problem KPP // Math proof series, book 3 Kindle Edition
by Archimedes Plutonium (Author)

There has been a alleged proof of KPP by Thomas Hales, but his is a fakery because he does not define what infinity actually means, for it means a borderline between finite and infinite numbers. Thus, KPP was never going to be proven until a well-defined infinity borderline was addressed within the proof. And because infinity has a borderline means that in free space with no borderlines to tackle and contend with, the 12 kissing point density that is the hexagonal close packed is the maximum density. But the truth and reality of Kepler Packing is asking for maximum packing out to infinity. That means you have to contend and fight with the packing of identical spheres up against a wall or border. And so, in tackling that wall, we can shift the hexagonal closed pack to another type of packing, a hybrid type of packing in order to get "maximum packing". So no proof ever of KPP is going to happen unless the proof tackles a infinity border wall. In free-space, a far distance away from a wall barrier of infinity border, then, hexagonal closed pack reigns and is the packing in all of free space-- but, the moment the packing gets nearby the walls of infinity border, then, we re-arrange the hexagonal closed pack to fit in more spheres. Not unlike us packing a suitcase and then rearranging to fit in more.

Cover picture: is a container and so the closed packing must be modified once the border is nearly reached to maximize the number of spheres.

Product details
• ASIN ‏ : ‎ B07NMV8NQQ
• Publication date ‏ : ‎ March 20, 2019
• Language ‏ : ‎ English
• File size ‏ : ‎ 1241 KB
• Text-to-Speech ‏ : ‎ Enabled
• Screen Reader ‏ : ‎ Supported
• Enhanced typesetting ‏ : ‎ Enabled
• X-Ray ‏ : ‎ Not Enabled
• Word Wise ‏ : ‎ Not Enabled
• Print length ‏ : ‎ 60 pages
• Lending ‏ : ‎ Enabled

#11-4, 28th published book

World's First Valid Proof of 4 Color Mapping Problem// Math proof series, book 4 Kindle Edition
by Archimedes Plutonium (Author)

Now in the math literature it is alleged that Appel & Haken proved this conjecture that 4 colors are sufficient to color all planar maps such that no two adjacent countries have the same color. Appel & Haken's fake proof was a computer proof and it is fake because their method is Indirect Nonexistence method. Unfortunately in the time of Appel & Haken few in mathematics had a firm grip on true Logic, where they did not even know that Boole's logic is fakery with his 3 OR 2 = 5 with 3 AND 2 = 1, when even the local village idiot knows that 3 AND 2 = 5 with 3 OR 2 = either 3 or 2 depending on which is subtracted. But the grave error in logic of Appel & Haken is their use of a utterly fake method of proof-- indirect nonexistence (see my textbook on Reductio Ad Absurdum). Wiles with his alleged proof of Fermat's Last Theorem is another indirect nonexistence as well as Hales's fake proof of Kepler Packing is indirect nonexistence.
Appel & Haken were in a time period when computers used in mathematics was a novelty, and instead of focusing on whether their proof was sound, everyone was dazzled not with the logic argument but the fact of using computers to generate a proof. And of course big big money was attached to this event and so, math is stuck with a fake proof of 4-Color-Mapping. And so, AP starting in around 1993, eventually gives the World's first valid proof of 4-Color-Mapping. Sorry, no computer fanfare, but just strict logical and sound argument.

Cover picture: Shows four countries colored yellow, red, green, purple and all four are mutually adjacent. And where the Purple colored country is landlocked, so that if it were considered that a 5th color is needed, that 5th color should be purple, hence, 4 colors are sufficient.

Product details
ASIN ‏ : ‎ B07PZ2Y5RV
Publication date ‏ : ‎ March 23, 2019
Language ‏ : ‎ English
File size ‏ : ‎ 1183 KB
Text-to-Speech ‏ : ‎ Enabled
Screen Reader ‏ : ‎ Supported
Enhanced typesetting ‏ : ‎ Enabled
X-Ray ‏ : ‎ Not Enabled
Word Wise ‏ : ‎ Not Enabled
Print length ‏ : ‎ 34 pages
Lending ‏ : ‎ Enabled

#11-5, 6th published book

World's First Valid Proofs of Fermat's Last Theorem, 1993 & 2014 // Math proof series, book 5 Kindle Edition
by Archimedes Plutonium (Author)

Last revision was 29Apr2021. This is AP's 6th published book.

Preface:
Real proofs of Fermat's Last Theorem// including the fake Euler proof in exp3 and Wiles fake proof.

Recap summary: In 1993 I proved Fermat's Last Theorem with a pure algebra proof, arguing that because of the special number 4 where 2 + 2 = 2^2 = 2*2 = 4 that this special feature of a unique number 4, allows for there to exist solutions to A^2 + B^2 = C^2. That the number 4 is a basis vector allowing more solutions to exist in exponent 2. But since there is no number with N+N+N = N*N*N that exists, there cannot be a solution in exp3 and the same argument for higher exponents. In 2014, I went and proved Generalized FLT by using "condensed rectangles". Once I had proven Generalized, then Regular FLT comes out of that proof as a simple corollary. So I had two proofs of Regular FLT, pure algebra and a corollary from Generalized FLT. Then recently in 2019, I sought to find a pure algebra proof of Generalized FLT, and I believe I accomplished that also by showing solutions to Generalized FLT also come from the special number 4 where 2 + 2 = 2^2 = 2*2 = 4. Amazing how so much math comes from the specialness of 4, where I argue that a Vector Space of multiplication provides the Generalized FLT of A^x + B^y = C^z.

AndrewWiles,Terence Tao, Thomas Hales, Jill Pipher, Ken Ribet, John Stillwell need to go to their affiliated University student newspaper and publish their apology for teaching the brainwashed propaganda that a slant cut in single cone is a ellipse when it is in fact a Oval, never the ellipse, for a single cone has only 1 axis of symmetry.

Because they were failures in ever recognizing a slant cut in single cone is a oval, meant they were failures all their life long in mathematics, never realizing that Calculus was geometry, and the Fundamental Theorem of Calculus required a geometry proof, not their mindless dumb and stupid limit-analysis.

AP's Proof-Ellipse was never a Conic Section // Math proof series, book 1 Kindle Edition
by Archimedes Plutonium (Author)

Ever since Ancient Greek Times it was thought the slant cut into a cone is the ellipse. That was false. For the slant cut in every cone is a Oval, never an Ellipse. This book is a proof that the slant cut is a oval, never the ellipse. A slant cut into the Cylinder is in fact a ellipse, but never in a cone.

Product details
• ASIN ‏ : ‎ B07PLSDQWC
• Publication date ‏ : ‎ March 11, 2019
• Language ‏ : ‎ English
• File size ‏ : ‎ 1621 KB
• Text-to-Speech ‏ : ‎ Enabled
• Enhanced typesetting ‏ : ‎ Enabled
• X-Ray ‏ : ‎ Not Enabled
• Word Wise ‏ : ‎ Not Enabled
• Print length ‏ : ‎ 20 pages
• Lending ‏ : ‎ Enabled
•
•

#11-2, 11th published book

World's First Geometry Proof of Fundamental Theorem of Calculus// Math proof series, book 2 Kindle Edition
by Archimedes Plutonium (Author)

Last revision was 15Dec2021. This is AP's 11th published book of science.
Preface:
Actually my title is too modest, for the proof that lies within this book makes it the World's First Valid Proof of Fundamental Theorem of Calculus, for in my modesty, I just wanted to emphasis that calculus was geometry and needed a geometry proof. Not being modest, there has never been a valid proof of FTC until AP's 2015 proof. This also implies that only a geometry proof of FTC constitutes a valid proof of FTC.

Calculus needs a geometry proof of Fundamental Theorem of Calculus. But none could ever be obtained in Old Math so long as they had a huge mass of mistakes, errors, fakes and con-artist trickery such as the "limit analysis". And very surprising that most math professors cannot tell the difference between a "proving something" and that of "analyzing something". As if an analysis is the same as a proof. We often analyze various things each and every day, but few if none of us consider a analysis as a proof. Yet that is what happened in the science of mathematics where they took an analysis and elevated it to the stature of being a proof, when it was never a proof.

To give a Geometry Proof of Fundamental Theorem of Calculus requires math be cleaned-up and cleaned-out of most of math's mistakes and errors. So in a sense, a Geometry FTC proof is a exercise in Consistency of all of Mathematics. In order to prove a FTC geometry proof, requires throwing out the error filled mess of Old Math. Can the Reals be the true numbers of mathematics if the Reals cannot deliver a Geometry proof of FTC? Can the functions that are not polynomial functions allow us to give a Geometry proof of FTC? Can a Coordinate System in 2D have 4 quadrants and still give a Geometry proof of FTC? Can a equation of mathematics with a number that is _not a positive decimal Grid Number_ all alone on the right side of the equation, at all times, allow us to give a Geometry proof of the FTC?

Cover Picture: Is my hand written, one page geometry proof of the Fundamental Theorem of Calculus, the world's first geometry proof of FTC, 2013-2015, by AP.

Product details
ASIN ‏ : ‎ B07PQTNHMY
Publication date ‏ : ‎ March 14, 2019
Language ‏ : ‎ English
File size ‏ : ‎ 1309 KB
Text-to-Speech ‏ : ‎ Enabled
Screen Reader ‏ : ‎ Supported
Enhanced typesetting ‏ : ‎ Enabled
X-Ray ‏ : ‎ Not Enabled
Word Wise ‏ : ‎ Not Enabled
Print length ‏ : ‎ 154 pages
Lending ‏ : ‎ Enabled
Amazon Best Sellers Rank: #128,729 Paid in Kindle Store (See Top 100 Paid in Kindle Store)
#2 in 45-Minute Science & Math Short Reads
#134 in Calculus (Books)
#20 in Calculus (Kindle Store)

#11-3, 24th published book

World's First Proof of Kepler Packing Problem KPP // Math proof series, book 3 Kindle Edition
by Archimedes Plutonium (Author)

There has been a alleged proof of KPP by Thomas Hales, but his is a fakery because he does not define what infinity actually means, for it means a borderline between finite and infinite numbers. Thus, KPP was never going to be proven until a well-defined infinity borderline was addressed within the proof. And because infinity has a borderline means that in free space with no borderlines to tackle and contend with, the 12 kissing point density that is the hexagonal close packed is the maximum density. But the truth and reality of Kepler Packing is asking for maximum packing out to infinity. That means you have to contend and fight with the packing of identical spheres up against a wall or border. And so, in tackling that wall, we can shift the hexagonal closed pack to another type of packing, a hybrid type of packing in order to get "maximum packing". So no proof ever of KPP is going to happen unless the proof tackles a infinity border wall. In free-space, a far distance away from a wall barrier of infinity border, then, hexagonal closed pack reigns and is the packing in all of free space-- but, the moment the packing gets nearby the walls of infinity border, then, we re-arrange the hexagonal closed pack to fit in more spheres. Not unlike us packing a suitcase and then rearranging to fit in more.

Cover picture: is a container and so the closed packing must be modified once the border is nearly reached to maximize the number of spheres.

Product details
• ASIN ‏ : ‎ B07NMV8NQQ
• Publication date ‏ : ‎ March 20, 2019
• Language ‏ : ‎ English
• File size ‏ : ‎ 1241 KB
• Text-to-Speech ‏ : ‎ Enabled
• Screen Reader ‏ : ‎ Supported
• Enhanced typesetting ‏ : ‎ Enabled
• X-Ray ‏ : ‎ Not Enabled
• Word Wise ‏ : ‎ Not Enabled
• Print length ‏ : ‎ 60 pages
• Lending ‏ : ‎ Enabled

#11-4, 28th published book

World's First Valid Proof of 4 Color Mapping Problem// Math proof series, book 4 Kindle Edition
by Archimedes Plutonium (Author)

Now in the math literature it is alleged that Appel & Haken proved this conjecture that 4 colors are sufficient to color all planar maps such that no two adjacent countries have the same color. Appel & Haken's fake proof was a computer proof and it is fake because their method is Indirect Nonexistence method. Unfortunately in the time of Appel & Haken few in mathematics had a firm grip on true Logic, where they did not even know that Boole's logic is fakery with his 3 OR 2 = 5 with 3 AND 2 = 1, when even the local village idiot knows that 3 AND 2 = 5 with 3 OR 2 = either 3 or 2 depending on which is subtracted. But the grave error in logic of Appel & Haken is their use of a utterly fake method of proof-- indirect nonexistence (see my textbook on Reductio Ad Absurdum). Wiles with his alleged proof of Fermat's Last Theorem is another indirect nonexistence as well as Hales's fake proof of Kepler Packing is indirect nonexistence.
Appel & Haken were in a time period when computers used in mathematics was a novelty, and instead of focusing on whether their proof was sound, everyone was dazzled not with the logic argument but the fact of using computers to generate a proof. And of course big big money was attached to this event and so, math is stuck with a fake proof of 4-Color-Mapping. And so, AP starting in around 1993, eventually gives the World's first valid proof of 4-Color-Mapping. Sorry, no computer fanfare, but just strict logical and sound argument.

Cover picture: Shows four countries colored yellow, red, green, purple and all four are mutually adjacent. And where the Purple colored country is landlocked, so that if it were considered that a 5th color is needed, that 5th color should be purple, hence, 4 colors are sufficient.

Product details
ASIN ‏ : ‎ B07PZ2Y5RV
Publication date ‏ : ‎ March 23, 2019
Language ‏ : ‎ English
File size ‏ : ‎ 1183 KB
Text-to-Speech ‏ : ‎ Enabled
Screen Reader ‏ : ‎ Supported
Enhanced typesetting ‏ : ‎ Enabled
X-Ray ‏ : ‎ Not Enabled
Word Wise ‏ : ‎ Not Enabled
Print length ‏ : ‎ 34 pages
Lending ‏ : ‎ Enabled

#11-5, 6th published book

World's First Valid Proofs of Fermat's Last Theorem, 1993 & 2014 // Math proof series, book 5 Kindle Edition
by Archimedes Plutonium (Author)

Last revision was 29Apr2021. This is AP's 6th published book.

Preface:
Real proofs of Fermat's Last Theorem// including the fake Euler proof in exp3 and Wiles fake proof.

Recap summary: In 1993 I proved Fermat's Last Theorem with a pure algebra proof, arguing that because of the special number 4 where 2 + 2 = 2^2 = 2*2 = 4 that this special feature of a unique number 4, allows for there to exist solutions to A^2 + B^2 = C^2. That the number 4 is a basis vector allowing more solutions to exist in exponent 2. But since there is no number with N+N+N = N*N*N that exists, there cannot be a solution in exp3 and the same argument for higher exponents. In 2014, I went and proved Generalized FLT by using "condensed rectangles". Once I had proven Generalized, then Regular FLT comes out of that proof as a simple corollary. So I had two proofs of Regular FLT, pure algebra and a corollary from Generalized FLT. Then recently in 2019, I sought to find a pure algebra proof of Generalized FLT, and I believe I accomplished that also by showing solutions to Generalized FLT also come from the special number 4 where 2 + 2 = 2^2 = 2*2 = 4. Amazing how so much math comes from the specialness of 4, where I argue that a Vector Space of multiplication provides the Generalized FLT of A^x + B^y = C^z.

AndrewWiles,Terence Tao, Thomas Hales, Jill Pipher, Ken Ribet, John Stillwell need to go to their affiliated University student newspaper and publish their apology for teaching the brainwashed propaganda that a slant cut in single cone is a ellipse when it is in fact a Oval, never the ellipse, for a single cone has only 1 axis of symmetry.

Because they were failures in ever recognizing a slant cut in single cone is a oval, meant they were failures all their life long in mathematics, never realizing that Calculus was geometry, and the Fundamental Theorem of Calculus required a geometry proof, not their mindless dumb and stupid limit-analysis.

AP's Proof-Ellipse was never a Conic Section // Math proof series, book 1 Kindle Edition
by Archimedes Plutonium (Author)

Ever since Ancient Greek Times it was thought the slant cut into a cone is the ellipse. That was false. For the slant cut in every cone is a Oval, never an Ellipse. This book is a proof that the slant cut is a oval, never the ellipse. A slant cut into the Cylinder is in fact a ellipse, but never in a cone.

Product details
• ASIN ‏ : ‎ B07PLSDQWC
• Publication date ‏ : ‎ March 11, 2019
• Language ‏ : ‎ English
• File size ‏ : ‎ 1621 KB
• Text-to-Speech ‏ : ‎ Enabled
• Enhanced typesetting ‏ : ‎ Enabled
• X-Ray ‏ : ‎ Not Enabled
• Word Wise ‏ : ‎ Not Enabled
• Print length ‏ : ‎ 20 pages
• Lending ‏ : ‎ Enabled
•
•

#11-2, 11th published book

World's First Geometry Proof of Fundamental Theorem of Calculus// Math proof series, book 2 Kindle Edition
by Archimedes Plutonium (Author)

Last revision was 15Dec2021. This is AP's 11th published book of science.
Preface:
Actually my title is too modest, for the proof that lies within this book makes it the World's First Valid Proof of Fundamental Theorem of Calculus, for in my modesty, I just wanted to emphasis that calculus was geometry and needed a geometry proof. Not being modest, there has never been a valid proof of FTC until AP's 2015 proof. This also implies that only a geometry proof of FTC constitutes a valid proof of FTC.

Calculus needs a geometry proof of Fundamental Theorem of Calculus. But none could ever be obtained in Old Math so long as they had a huge mass of mistakes, errors, fakes and con-artist trickery such as the "limit analysis". And very surprising that most math professors cannot tell the difference between a "proving something" and that of "analyzing something". As if an analysis is the same as a proof. We often analyze various things each and every day, but few if none of us consider a analysis as a proof. Yet that is what happened in the science of mathematics where they took an analysis and elevated it to the stature of being a proof, when it was never a proof.

To give a Geometry Proof of Fundamental Theorem of Calculus requires math be cleaned-up and cleaned-out of most of math's mistakes and errors. So in a sense, a Geometry FTC proof is a exercise in Consistency of all of Mathematics. In order to prove a FTC geometry proof, requires throwing out the error filled mess of Old Math. Can the Reals be the true numbers of mathematics if the Reals cannot deliver a Geometry proof of FTC? Can the functions that are not polynomial functions allow us to give a Geometry proof of FTC? Can a Coordinate System in 2D have 4 quadrants and still give a Geometry proof of FTC? Can a equation of mathematics with a number that is _not a positive decimal Grid Number_ all alone on the right side of the equation, at all times, allow us to give a Geometry proof of the FTC?

Cover Picture: Is my hand written, one page geometry proof of the Fundamental Theorem of Calculus, the world's first geometry proof of FTC, 2013-2015, by AP.

Product details
ASIN ‏ : ‎ B07PQTNHMY
Publication date ‏ : ‎ March 14, 2019
Language ‏ : ‎ English
File size ‏ : ‎ 1309 KB
Text-to-Speech ‏ : ‎ Enabled
Screen Reader ‏ : ‎ Supported
Enhanced typesetting ‏ : ‎ Enabled
X-Ray ‏ : ‎ Not Enabled
Word Wise ‏ : ‎ Not Enabled
Print length ‏ : ‎ 154 pages
Lending ‏ : ‎ Enabled
Amazon Best Sellers Rank: #128,729 Paid in Kindle Store (See Top 100 Paid in Kindle Store)
#2 in 45-Minute Science & Math Short Reads
#134 in Calculus (Books)
#20 in Calculus (Kindle Store)

#11-3, 24th published book

World's First Proof of Kepler Packing Problem KPP // Math proof series, book 3 Kindle Edition
by Archimedes Plutonium (Author)

There has been a alleged proof of KPP by Thomas Hales, but his is a fakery because he does not define what infinity actually means, for it means a borderline between finite and infinite numbers. Thus, KPP was never going to be proven until a well-defined infinity borderline was addressed within the proof. And because infinity has a borderline means that in free space with no borderlines to tackle and contend with, the 12 kissing point density that is the hexagonal close packed is the maximum density. But the truth and reality of Kepler Packing is asking for maximum packing out to infinity. That means you have to contend and fight with the packing of identical spheres up against a wall or border. And so, in tackling that wall, we can shift the hexagonal closed pack to another type of packing, a hybrid type of packing in order to get "maximum packing". So no proof ever of KPP is going to happen unless the proof tackles a infinity border wall. In free-space, a far distance away from a wall barrier of infinity border, then, hexagonal closed pack reigns and is the packing in all of free space-- but, the moment the packing gets nearby the walls of infinity border, then, we re-arrange the hexagonal closed pack to fit in more spheres. Not unlike us packing a suitcase and then rearranging to fit in more.

Cover picture: is a container and so the closed packing must be modified once the border is nearly reached to maximize the number of spheres.

Product details
• ASIN ‏ : ‎ B07NMV8NQQ
• Publication date ‏ : ‎ March 20, 2019
• Language ‏ : ‎ English
• File size ‏ : ‎ 1241 KB
• Text-to-Speech ‏ : ‎ Enabled
• Screen Reader ‏ : ‎ Supported
• Enhanced typesetting ‏ : ‎ Enabled
• X-Ray ‏ : ‎ Not Enabled
• Word Wise ‏ : ‎ Not Enabled
• Print length ‏ : ‎ 60 pages
• Lending ‏ : ‎ Enabled

#11-4, 28th published book

World's First Valid Proof of 4 Color Mapping Problem// Math proof series, book 4 Kindle Edition
by Archimedes Plutonium (Author)

Now in the math literature it is alleged that Appel & Haken proved this conjecture that 4 colors are sufficient to color all planar maps such that no two adjacent countries have the same color. Appel & Haken's fake proof was a computer proof and it is fake because their method is Indirect Nonexistence method. Unfortunately in the time of Appel & Haken few in mathematics had a firm grip on true Logic, where they did not even know that Boole's logic is fakery with his 3 OR 2 = 5 with 3 AND 2 = 1, when even the local village idiot knows that 3 AND 2 = 5 with 3 OR 2 = either 3 or 2 depending on which is subtracted. But the grave error in logic of Appel & Haken is their use of a utterly fake method of proof-- indirect nonexistence (see my textbook on Reductio Ad Absurdum). Wiles with his alleged proof of Fermat's Last Theorem is another indirect nonexistence as well as Hales's fake proof of Kepler Packing is indirect nonexistence.
Appel & Haken were in a time period when computers used in mathematics was a novelty, and instead of focusing on whether their proof was sound, everyone was dazzled not with the logic argument but the fact of using computers to generate a proof. And of course big big money was attached to this event and so, math is stuck with a fake proof of 4-Color-Mapping. And so, AP starting in around 1993, eventually gives the World's first valid proof of 4-Color-Mapping. Sorry, no computer fanfare, but just strict logical and sound argument.

Cover picture: Shows four countries colored yellow, red, green, purple and all four are mutually adjacent. And where the Purple colored country is landlocked, so that if it were considered that a 5th color is needed, that 5th color should be purple, hence, 4 colors are sufficient.

Product details
ASIN ‏ : ‎ B07PZ2Y5RV
Publication date ‏ : ‎ March 23, 2019
Language ‏ : ‎ English
File size ‏ : ‎ 1183 KB
Text-to-Speech ‏ : ‎ Enabled
Screen Reader ‏ : ‎ Supported
Enhanced typesetting ‏ : ‎ Enabled
X-Ray ‏ : ‎ Not Enabled
Word Wise ‏ : ‎ Not Enabled
Print length ‏ : ‎ 34 pages
Lending ‏ : ‎ Enabled

#11-5, 6th published book

World's First Valid Proofs of Fermat's Last Theorem, 1993 & 2014 // Math proof series, book 5 Kindle Edition
by Archimedes Plutonium (Author)

Last revision was 29Apr2021. This is AP's 6th published book.

Preface:
Real proofs of Fermat's Last Theorem// including the fake Euler proof in exp3 and Wiles fake proof.

Recap summary: In 1993 I proved Fermat's Last Theorem with a pure algebra proof, arguing that because of the special number 4 where 2 + 2 = 2^2 = 2*2 = 4 that this special feature of a unique number 4, allows for there to exist solutions to A^2 + B^2 = C^2. That the number 4 is a basis vector allowing more solutions to exist in exponent 2. But since there is no number with N+N+N = N*N*N that exists, there cannot be a solution in exp3 and the same argument for higher exponents. In 2014, I went and proved Generalized FLT by using "condensed rectangles". Once I had proven Generalized, then Regular FLT comes out of that proof as a simple corollary. So I had two proofs of Regular FLT, pure algebra and a corollary from Generalized FLT. Then recently in 2019, I sought to find a pure algebra proof of Generalized FLT, and I believe I accomplished that also by showing solutions to Generalized FLT also come from the special number 4 where 2 + 2 = 2^2 = 2*2 = 4. Amazing how so much math comes from the specialness of 4, where I argue that a Vector Space of multiplication provides the Generalized FLT of A^x + B^y = C^z.

On 1/22/2022 10:43 PM, Richard Damon wrote:
> On 1/22/22 11:34 PM, olcott wrote:
>> On 1/22/2022 3:36 PM, Richard Damon wrote:
>>> On 1/22/22 4:25 PM, olcott wrote:
>>>> On 1/22/2022 3:20 PM, Richard Damon wrote:
>>>>>
>>
>>>> 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'.
>>
>> Anyone that knows that x86 language can tell that its easy to match
>> the infinite loop pattern:
>>
>> _Infinite_Loop()
>> [000015fa](01)  55              push ebp
>> [000015fb](02)  8bec            mov ebp,esp
>> [000015fd](02)  ebfe            jmp 000015fd
>> [000015ff](01)  5d              pop ebp
>> [00001600](01)  c3              ret
>> Size in bytes:(0007) [00001600]
>>
>> ---[000015fa][002126f0][002126f4] 55              push ebp
>> ---[000015fb][002126f0][002126f4] 8bec            mov ebp,esp
>> ---[000015fd][002126f0][002126f4] ebfe            jmp 000015fd
>> ---[000015fd][002126f0][002126f4] ebfe            jmp 000015fd
>
> Showing that you can do one case does not prove that the same method
> works on all, particularly harder methods.
>
> That is just you serving Red Herring.
>
> And that pattern does NOT show up in the simulation by H of H^
>
> Which makes it MORE lies by Red Herring.
>
> FAIL.
>
> Total lack of proof.
>>
>>> Does the proof include the posibility that the input includes a copy
>>> of the decider?
>>>
>>
>> It is always the case that a simulating halt decider can correctly
>> base its halt status decision on the behavior pure simulation of its
>> input.
>
> LIE.
>
> Proven incorrect.
>
> If H -> H.Qn then H^ -> H^.Qn and Halts and for H^ <H^> proves H wrong.
>
>>
>> We know that this must be true because we know that the pure UTM
>> simulation of an Turing Machine description is defined to have
>> equivalent behavior to that of the direct execution of the same machine
>>
>
> Right, but that does't prove what you sy.
>
> You are just LYING out of your POOP.
>
>>
>>> 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 is not answering the question: Does the input stop running?
>
>
> YOU need to answer, which H are you using?
>
> If H doesn't abort, then H^ is non-halting, but H will never answer.
>
> If H does abort and go to H.Qn, then the pure simulation of the input
> WILL halt at H^.Qn, so H was wrong.
>
> FAIL.
>
>>
>> It is answering the question:
>> Would the pure simulation of the input ever stop running?
>
> Right, and if H -> H.Qn it will.
>
> FAIL.
>
YOU JUST AREN'T BRIGHT ENOUGH TO GET THIS. IT CAN BE VERIFIED AS
COMPLETELY TRUE ENTIRELY ON THE BASIS OF THE MEANING OF ITS WORDS.

It is the case that if embedded_H recognizes an infinitely repeating
pattern in the simulation of its input such that this correctly
simulated input cannot possibly reach its final state then this is
complete prove that this simulated input never halts.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 1/24/2022 8:26 PM, Richard Damon wrote:
> On 1/24/22 9:11 PM, olcott wrote:
>> On 1/24/2022 8:03 PM, Richard Damon wrote:
>>>
>>> On 1/24/22 8:32 PM, olcott wrote:
>>>> On 1/24/2022 6:50 PM, Richard Damon wrote:
>>>>> On 1/24/22 7:09 PM, olcott wrote:
>>>>>> On 1/24/2022 5:49 PM, Richard Damon wrote:
>>>>>>> On 1/24/22 10:03 AM, olcott wrote:
>>>>>>>> On 1/23/2022 10:45 PM, Richard Damon wrote:
>>>>>>>>> On 1/23/22 11:17 PM, olcott wrote:
>>>>>>>>>> On 1/23/2022 9:57 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 1/23/22 10:40 PM, olcott wrote:
>>>>>>>>>>>> On 1/23/2022 9:24 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/23/22 10:10 PM, olcott wrote:
>>>>>>>>>>>>>> On 1/23/2022 8:42 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 1/23/22 9:29 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 1/23/2022 8:14 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 1/23/22 9:03 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 1/23/2022 7:55 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 1/23/22 8:10 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 1/23/2022 7:00 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 1/23/22 7:25 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 6:09 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 7:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 5:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 6:16 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 5:06 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 5:47 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 4:40 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 5:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 4:01 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 4:40 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 2:25 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 2:19 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 10:43 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 11:34 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 3:36 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 4:25 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 3:20 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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'.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Anyone that knows that x86 language
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can tell that its easy to match the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite loop pattern:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fa](01)  55              push
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fb](02)  8bec            mov
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fd](02)  ebfe            jmp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015ff](01)  5d              pop ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001600](01)  c3              ret
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0007) [00001600]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fa][002126f0][002126f4] 55
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fb][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fd][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebfe jmp 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fd][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebfe jmp 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Showing that you can do one case does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not prove that the same method works
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on all, particularly harder methods.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is just you serving Red Herring.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And that pattern does NOT show up in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation by H of H^
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Which makes it MORE lies by Red Herring.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Total lack of proof.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does the proof include the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> posibility that the input includes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a copy of the decider?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is always the case that a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly base its halt status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decision on the behavior pure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> LIE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Proven incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H -> H.Qn then H^ -> H^.Qn and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halts and for H^ <H^> proves H wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We know that this must be true
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because we know that the pure UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of an Turing Machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> description is defined to have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> equivalent behavior to that of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> direct execution of the same machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, but that does't prove what you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sy.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are just LYING out of your POOP.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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 is not answering the question:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does the input stop running?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU need to answer, which H are you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> using?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H doesn't abort, then H^ is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting, but H will never answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H does abort and go to H.Qn, then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the pure simulation of the input WILL
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt at H^.Qn, so H was wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is answering the question:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Would the pure simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input ever stop running?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, and if H -> H.Qn it will.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU JUST AREN'T BRIGHT ENOUGH TO GET
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THIS. IT CAN BE VERIFIED AS COMPLETELY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> TRUE ENTIRELY ON THE BASIS OF THE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> MEANING OF ITS WORDS.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is the case that if embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recognizes an infinitely repeating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern in the simulation of its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> such that this correctly simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input cannot possibly reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state then this is complete prove that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this simulated input never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If it COULD CORRECTLY recognize an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely repeating pattern in its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation that can not possibly reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final state (when simulated by a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM, not just H) then, YES, H can go to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H.Qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The problem is that due to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 'pathological self-reference' in H^,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ANY pattern that H sees in its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of <H^> <H^> that it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> transitions to H.Qn, will BY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DEFINITION, become a halting pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So a correctly simulated INPUT that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly reach its final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches its final state anyway. YOU ARE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DUMBER THAN A BOX OF ROCKS !!!
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That's not what I said, I said there is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> no pattern that H use to detect that it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> won't halt, as any pattern that H uses to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decide to go to H.Qn will be WRONG for H^
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as if H goes to H.Qn, then H^ also goes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H^.Qn and Halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When the correctly simulated INPUT to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H cannot possibly reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state it is necessarily correct for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H to report that its correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT cannot possibly reach its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right,  but you have only proved that H^ is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting for the case where H doesn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because you are dumber than a box of rocks
>>>>>>>>>>>>>>>>>>>>>>>>>>>> (or perhaps you are a bot?)
>>>>>>>>>>>>>>>>>>>>>>>>>>>> You did not notice that I never mentioned
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the word: "halting".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> For a human being you are much dumber than a
>>>>>>>>>>>>>>>>>>>>>>>>>>>> box of rocks.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> For a bot you did quite well (you nearly
>>>>>>>>>>>>>>>>>>>>>>>>>>>> passed the Turing test) it took me this long
>>>>>>>>>>>>>>>>>>>>>>>>>>>> to realize that you are not a human being.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> But reaching final state is the same as Halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You have only prove that the pure simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>> of the input to H never reaches a final state
>>>>>>>>>>>>>>>>>>>>>>>>>>> for case when H doesn't abort its simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> You deliberate weasel words do not apply to
>>>>>>>>>>>>>>>>>>>>>>>>>> what I said:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Premise: When the correctly simulated
>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT to embedded_H cannot possibly reach its
>>>>>>>>>>>>>>>>>>>>>>>>>> final state
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> (2) Conclusion: It is necessarily correct for
>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H to report that its correctly
>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT cannot possibly reach its
>>>>>>>>>>>>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> And the correct simulation of the input to H is
>>>>>>>>>>>>>>>>>>>>>>>>> determined by the UTM, not H.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> (2) is a logical consequence of (1).
>>>>>>>>>>>>>>>>>>>>>>>> It is logically incorrect to argue with a
>>>>>>>>>>>>>>>>>>>>>>>> deductive logical premise.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> But 1 is only true if H doesn't go to H.Qn, so H
>>>>>>>>>>>>>>>>>>>>>>> can't correctly go to H.Qn.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You are quite the deceiver making sure to always
>>>>>>>>>>>>>>>>>>>>>> change the subject rather than directly address
>>>>>>>>>>>>>>>>>>>>>> the point at hand.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> And you seem quite dense. I did NOT change the
>>>>>>>>>>>>>>>>>>>>> subject, I pointed out an error in your statement.
>>>>>>>>>>>>>>>>>>>>> You seem to be unable to comprehend that.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> (2) logically follows from (1) is true.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> But 1 ISN'T True if H <H^> <H^> -> H.Qn, as the
>>>>>>>>>>>>>>>>>>>>> correctly simulate input
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> When testing whether or not one assertion logically
>>>>>>>>>>>>>>>>>>>> follows from another the premises are always "given"
>>>>>>>>>>>>>>>>>>>> to be true even if they are false.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Don't know what sort of logic you are claiming.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> And arguemnt with a false premise is unsound.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> We are not yet looking at soundness we are looking at
>>>>>>>>>>>>>>>>>> validity.
>>>>>>>>>>>>>>>>>> It is true that (2) logically follows from (1).
>>>>>>>>>>>>>>>>>> We can't move on from this one point until we have
>>>>>>>>>>>>>>>>>> mutual agreement.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Very strange then, why are you arguing about that which
>>>>>>>>>>>>>>>>> was accepted unless you disagree to the conditions that
>>>>>>>>>>>>>>>>> they were accepted under?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It has long been accepted that the under the
>>>>>>>>>>>>>>>>> hypothetical condition where H can actually determine
>>>>>>>>>>>>>>>>> that the UTM will run forever, it is correct (and in
>>>>>>>>>>>>>>>>> fact needed to be correct) for H to go to H.Qn and say
>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> OKAY so then you agree with this?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (1) Premise: When the correctly simulated INPUT to
>>>>>>>>>>>>>>>> embedded_H
>>>>>>>>>>>>>>>> cannot possibly reach its final state
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (2) Conclusion: It is necessarily correct for embedded_H to
>>>>>>>>>>>>>>>> report that its correctly simulated INPUT cannot possibly
>>>>>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Under the definition that 'correctly simulated input' is
>>>>>>>>>>>>>>> as determined by a UTM, not H (if it aborts its simulation).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It is only stipulated to be correct other details are
>>>>>>>>>>>>>> currently unspecified.
>>>>>>>>>>>>>
>>>>>>>>>>>>> That isn't a 'stipulation', that is a DEFINITION.
>>>>>>>>>>>>>
>>>>>>>>>>>>> This is obviously your attempt at being a weasel.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The DEFINITION of correct simulation is the results of a
>>>>>>>>>>>>> UTM simulating the input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Any deviaiton in this means you are just eating your POOP.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It also does not presume that H CAN determine that this
>>>>>>>>>>>>>>> condition exists, so it would be correct, but H might not
>>>>>>>>>>>>>>> be able to decide to do so. So it may be correct for it
>>>>>>>>>>>>>>> to do so, but it might not actually be able to do it.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> There is also the case you tend to ignore that you start
>>>>>>>>>>>>>>> with an H that is defined to NOT abort, but you try to
>>>>>>>>>>>>>>> use (2) to claim that it now can abort, the H is (2) must
>>>>>>>>>>>>>>> be the same H that the H^ in (1) was built form
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> All of these restrictions are actually in the actual
>>>>>>>>>>>>>>> meaning of the words you are using, from the context of
>>>>>>>>>>>>>>> the problem, but I state them because knowing you, you
>>>>>>>>>>>>>>> are going to try to break that restrictions.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> This seems to be the very first time that you actually
>>>>>>>>>>>>>> paid close attention, good jo
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> As I asked, how is that different from the statement of
>>>>>>>>>>>>>>> the requirements on H?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> 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 its simulated input would never reach its own
>>>>>>>>>>>>>> final state. In this case H aborts the simulation of this
>>>>>>>>>>>>>> input and transitions to H.qn.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Note, The correct answer is NOT based on a simulation of N
>>>>>>>>>>>>> steps, but a simulation by a UTM which will run until it
>>>>>>>>>>>>> halts.
>>>>>>>>>>>>>
>>>>>>>>>>>>> H needs to make ITS decision on the limited N step, so it
>>>>>>>>>>>>> needs to prove that its answer matches.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Remember, when we do this run, H is defined, and thus N is
>>>>>>>>>>>>> a SPECIFIC number, not an 'arbitrary' number.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You also will need to some how prove that a pattern exists
>>>>>>>>>>>>> in N steps that correct dectect non-halting.
>>>>>>>>>>>>>
>>>>>>>>>>>>> This has been previously shown to be impossible, so you
>>>>>>>>>>>>> need to actually come up with it or show an actual error in
>>>>>>>>>>>>> the proof. You can't just assume it exists.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Great we can move to the next step:
>>>>>>>>>>>>
>>>>>>>>>>>> (1) Premise: When embedded_H correctly determines its
>>>>>>>>>>>> simulated INPUT to
>>>>>>>>>>>> embedded_H cannot possibly reach its final state
>>>>>>>>>>>>
>>>>>>>>>>>> (2) Conclusion: It is necessarily correct for embedded_H to
>>>>>>>>>>>> report that its correctly simulated INPUT cannot possibly
>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>> WARNING, you are getting way into hypothecctica Unicoprn
>>>>>>>>>>> Terretory, but lets unpack this statement.
>>>>>>>>>>>
>>>>>>>>>>> IF H can correctly deteremine (that means that there needs to
>>>>>>>>>>> exist a finite algroithm to determine this case, and that
>>>>>>>>>>> this result matches the behavior demonstrated by the
>>>>>>>>>>> definitional UTM simulataion of this input), that the input
>>>>>>>>>>> will NEVER reach it final state,
>>>>>>>>>>>
>>>>>>>>>>> Then yes, it is correct for H to report that its input can
>>>>>>>>>>> not possible reach its final state.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Great we have finally begun an honest dialogue.
>>>>>>>>>>
>>>>>>>>>>> Note, that if H does this, then the proof that the input
>>>>>>>>>>> never reached its final state must have included that fact
>>>>>>>>>>> that the copy of H inside H^ will also do the exact same
>>>>>>>>>>> thing with the exact same input.
>>>>>>>>>>>
>>>>>>>>>>> Also, to show the premise is True, you need to be able to
>>>>>>>>>>> PROVE or actually provide the exact finite algorithm that it
>>>>>>>>>>> used to detemine this fact.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ these steps would
>>>>>>>>>> keep repeating:
>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Only if H doesn't abort it simulation.
>>>>>>>>>
>>>>>>>>
>>>>>>>> On the basis that the pure simulation of N steps matches an
>>>>>>>> infinitely repeating pattern embedded_H can correctly determine
>>>>>>>> that this simulated input cannot possibly reach its final state
>>>>>>>> whether or not embedded_H aborts its simulation of this input.
>>>>>>>
>>>>>>> WHAT N Step pattern shows that H^ <H^> is non-halting.
>>>>>>>
>>>>>>
>>>>>> When embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ these steps would
>>>>>> keep repeating:
>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>
>>>>> If that is what happens, then obviously H never aborted its
>>>>> simulation, so it CAN'T.
>>>>>
>>>>>
>>>>
>>>> As soon as embedded_H correctly recognizes this infinitely repeating
>>>> pattern in its correct simulation of N steps of its input it is
>>>> necessarily correct for it to report that that its simulated input
>>>> cannot possibly ever reach its halt state.
>>>
>>> Only if it proved that it was correct if it does abort and go to
>>> H.Qn, which it can't.
>> With logical entailment the conclusion follows from the premise(s) by
>> logical necessity.
>>
>> (1) As soon as embedded_H correctly recognizes this infinitely
>> repeating pattern in its correct simulation of N steps of its input
>
> Which makes the falicay of assuming there is a CORRECT pattern for H to
> detect in H^, and that H has the ability to detect it.
>

On 1/25/2022 5:55 AM, Richard Damon wrote:
> On 1/25/22 12:27 AM, olcott wrote:
>> On 1/24/2022 11:15 PM, Richard Damon wrote:
>>>
>>> On 1/25/22 12:04 AM, olcott wrote:
>>>> On 1/24/2022 10:54 PM, Richard Damon wrote:
>>>>>
>>>>> On 1/24/22 11:28 PM, olcott wrote:
>>>>>> On 1/24/2022 10:25 PM, Richard Damon wrote:
>>>>>>> On 1/24/22 11:19 PM, olcott wrote:
>>>>>>>> On 1/24/2022 10:16 PM, Richard Damon wrote:
>>>>>>>>> On 1/24/22 10:58 PM, olcott wrote:
>>>>>>>>>> On 1/24/2022 9:50 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/24/22 10:45 PM, olcott wrote:
>>>>>>>>>>>> On 1/24/2022 8:26 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/24/22 9:11 PM, olcott wrote:
>>>>>>>>>>>>>> On 1/24/2022 8:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 1/24/22 8:32 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 1/24/2022 6:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 1/24/22 7:09 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 1/24/2022 5:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 1/24/22 10:03 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 1/23/2022 10:45 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 1/23/22 11:17 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 9:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 10:40 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 9:24 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 10:10 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 8:42 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 9:29 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 8:14 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 9:03 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 7:55 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 8:10 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 7:00 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 7:25 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 6:09 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 7:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 5:50 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 6:16 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 5:06 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 5:47 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 4:40 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 5:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 4:01 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 4:40 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 2:25 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 2:19 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 10:43 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 11:34 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 3:36 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 4:25 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 3:20 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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'.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Anyone that knows that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> x86 language can tell
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its easy to match
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the infinite loop pattern:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fa](01)  55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fb](02)  8bec mov
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fd](02)  ebfe jmp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015ff](01)  5d pop ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001600](01)  c3 ret
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0007)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001600]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fa][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fb][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fd][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebfe jmp 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fd][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebfe jmp 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Showing that you can do
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> one case does not prove
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the same method
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> works on all,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> particularly harder methods.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is just you serving
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Red Herring.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And that pattern does NOT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> show up in the simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by H of H^
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Which makes it MORE lies
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by Red Herring.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Total lack of proof.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does the proof include
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the posibility that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input includes a copy
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the decider?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is always the case
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that a simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider can correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> base its halt status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decision on the behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pure simulation of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> LIE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Proven incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H -> H.Qn then H^ ->
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^.Qn and Halts and for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^ <H^> proves H wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We know that this must
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be true because we know
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the pure UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of an Turing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Machine description is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> defined to have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> equivalent behavior to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that of the direct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution of the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, but that does't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove what you sy.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are just LYING out of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your POOP.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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 is not answering the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question: Does the input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> stop running?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU need to answer, which
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H are you using?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H doesn't abort, then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^ is non-halting, but H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will never answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H does abort and go to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H.Qn, then the pure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WILL halt at H^.Qn, so H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> was wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is answering the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Would the pure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ever stop running?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, and if H -> H.Qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it will.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU JUST AREN'T BRIGHT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ENOUGH TO GET THIS. IT CAN
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> BE VERIFIED AS COMPLETELY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> TRUE ENTIRELY ON THE BASIS
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> OF THE MEANING OF ITS WORDS.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is the case that if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H recognizes an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely repeating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern in the simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input such that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this correctly simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final state then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this is complete prove
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that this simulated input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If it COULD CORRECTLY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recognize an infinitely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeating pattern in its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation that can not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state (when simulated by a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM, not just H) then, YES,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H can go to H.Qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The problem is that due to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 'pathological
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-reference' in H^, ANY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern that H sees in its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of <H^> <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it transitions to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H.Qn, will BY DEFINITION,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> become a halting pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So a correctly simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT that cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches its final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> anyway. YOU ARE DUMBER THAN
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A BOX OF ROCKS !!!
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That's not what I said, I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> said there is no pattern that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H use to detect that it won't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt, as any pattern that H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> uses to decide to go to H.Qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will be WRONG for H^ as if H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> goes to H.Qn, then H^ also
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> goes to H^.Qn and Halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When the correctly simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT to embedded_H cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it is necessarily correct for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H to report that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated INPUT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly reach its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right,  but you have only
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proved that H^ is non-halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for the case where H doesn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because you are dumber than a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> box of rocks (or perhaps you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a bot?)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You did not notice that I never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mentioned the word: "halting".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For a human being you are much
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dumber than a box of rocks.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For a bot you did quite well
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (you nearly passed the Turing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> test) it took me this long to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> realize that you are not a human
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> being.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But reaching final state is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same as Halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have only prove that the pure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the input to H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never reaches a final state for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> case when H doesn't abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You deliberate weasel words do not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> apply to what I said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Premise: When the correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT to embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly reach its final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) Conclusion: It is necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct for embedded_H to report
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its correctly simulated INPUT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And the correct simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H is determined by the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM, not H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) is a logical consequence of (1).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is logically incorrect to argue
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> with a deductive logical premise.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But 1 is only true if H doesn't go to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H.Qn, so H can't correctly go to H.Qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are quite the deceiver making sure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to always change the subject rather
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> than directly address the point at hand.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you seem quite dense. I did NOT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> change the subject, I pointed out an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> error in your statement. You seem to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unable to comprehend that.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) logically follows from (1) is true.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But 1 ISN'T True if H <H^> <H^> ->
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H.Qn, as the correctly simulate input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When testing whether or not one
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> assertion logically follows from another
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the premises are always "given" to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> true even if they are false.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Don't know what sort of logic you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> claiming.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And arguemnt with a false premise is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unsound.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We are not yet looking at soundness we are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> looking at validity.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is true that (2) logically follows from
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We can't move on from this one point until
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> we have mutual agreement.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Very strange then, why are you arguing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about that which was accepted unless you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disagree to the conditions that they were
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> accepted under?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It has long been accepted that the under
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the hypothetical condition where H can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually determine that the UTM will run
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> forever, it is correct (and in fact needed
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to be correct) for H to go to H.Qn and say
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> OKAY so then you agree with this?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Premise: When the correctly simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT to embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly reach its final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) Conclusion: It is necessarily correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>> for embedded_H to
>>>>>>>>>>>>>>>>>>>>>>>>>>>> report that its correctly simulated INPUT
>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Under the definition that 'correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input' is as determined by a UTM,
>>>>>>>>>>>>>>>>>>>>>>>>>>> not H (if it aborts its simulation).
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> It is only stipulated to be correct other
>>>>>>>>>>>>>>>>>>>>>>>>>> details are currently unspecified.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> That isn't a 'stipulation', that is a DEFINITION.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> This is obviously your attempt at being a weasel.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The DEFINITION of correct simulation is the
>>>>>>>>>>>>>>>>>>>>>>>>> results of a UTM simulating the input.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Any deviaiton in this means you are just eating
>>>>>>>>>>>>>>>>>>>>>>>>> your POOP.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> It also does not presume that H CAN determine
>>>>>>>>>>>>>>>>>>>>>>>>>>> that this condition exists, so it would be
>>>>>>>>>>>>>>>>>>>>>>>>>>> correct, but H might not be able to decide to
>>>>>>>>>>>>>>>>>>>>>>>>>>> do so. So it may be correct for it to do so,
>>>>>>>>>>>>>>>>>>>>>>>>>>> but it might not actually be able to do it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> There is also the case you tend to ignore
>>>>>>>>>>>>>>>>>>>>>>>>>>> that you start with an H that is defined to
>>>>>>>>>>>>>>>>>>>>>>>>>>> NOT abort, but you try to use (2) to claim
>>>>>>>>>>>>>>>>>>>>>>>>>>> that it now can abort, the H is (2) must be
>>>>>>>>>>>>>>>>>>>>>>>>>>> the same H that the H^ in (1) was built form
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> All of these restrictions are actually in the
>>>>>>>>>>>>>>>>>>>>>>>>>>> actual meaning of the words you are using,
>>>>>>>>>>>>>>>>>>>>>>>>>>> from the context of the problem, but I state
>>>>>>>>>>>>>>>>>>>>>>>>>>> them because knowing you, you are going to
>>>>>>>>>>>>>>>>>>>>>>>>>>> try to break that restrictions.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> This seems to be the very first time that you
>>>>>>>>>>>>>>>>>>>>>>>>>> actually paid close attention, good jo
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> As I asked, how is that different from the
>>>>>>>>>>>>>>>>>>>>>>>>>>> statement of the requirements on H?
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> 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 its
>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input would never reach its own
>>>>>>>>>>>>>>>>>>>>>>>>>> final state. In this case H aborts the
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of this input and transitions to H.qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Note, The correct answer is NOT based on a
>>>>>>>>>>>>>>>>>>>>>>>>> simulation of N steps, but a simulation by a
>>>>>>>>>>>>>>>>>>>>>>>>> UTM which will run until it halts.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> H needs to make ITS decision on the limited N
>>>>>>>>>>>>>>>>>>>>>>>>> step, so it needs to prove that its answer
>>>>>>>>>>>>>>>>>>>>>>>>> matches.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Remember, when we do this run, H is defined,
>>>>>>>>>>>>>>>>>>>>>>>>> and thus N is a SPECIFIC number, not an
>>>>>>>>>>>>>>>>>>>>>>>>> 'arbitrary' number.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> You also will need to some how prove that a
>>>>>>>>>>>>>>>>>>>>>>>>> pattern exists in N steps that correct dectect
>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> This has been previously shown to be
>>>>>>>>>>>>>>>>>>>>>>>>> impossible, so you need to actually come up
>>>>>>>>>>>>>>>>>>>>>>>>> with it or show an actual error in the proof.
>>>>>>>>>>>>>>>>>>>>>>>>> You can't just assume it exists.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Great we can move to the next step:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> (1) Premise: When embedded_H correctly
>>>>>>>>>>>>>>>>>>>>>>>> determines its simulated INPUT to
>>>>>>>>>>>>>>>>>>>>>>>> embedded_H cannot possibly reach its final state
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> (2) Conclusion: It is necessarily correct for
>>>>>>>>>>>>>>>>>>>>>>>> embedded_H to report that its correctly
>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT cannot possibly reach its final
>>>>>>>>>>>>>>>>>>>>>>>> state.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> WARNING, you are getting way into hypothecctica
>>>>>>>>>>>>>>>>>>>>>>> Unicoprn Terretory, but lets unpack this statement.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> IF H can correctly deteremine (that means that
>>>>>>>>>>>>>>>>>>>>>>> there needs to exist a finite algroithm to
>>>>>>>>>>>>>>>>>>>>>>> determine this case, and that this result matches
>>>>>>>>>>>>>>>>>>>>>>> the behavior demonstrated by the definitional UTM
>>>>>>>>>>>>>>>>>>>>>>> simulataion of this input), that the input will
>>>>>>>>>>>>>>>>>>>>>>> NEVER reach it final state,
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Then yes, it is correct for H to report that its
>>>>>>>>>>>>>>>>>>>>>>> input can not possible reach its final state.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Great we have finally begun an honest dialogue.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Note, that if H does this, then the proof that
>>>>>>>>>>>>>>>>>>>>>>> the input never reached its final state must have
>>>>>>>>>>>>>>>>>>>>>>> included that fact that the copy of H inside H^
>>>>>>>>>>>>>>>>>>>>>>> will also do the exact same thing with the exact
>>>>>>>>>>>>>>>>>>>>>>> same input.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Also, to show the premise is True, you need to be
>>>>>>>>>>>>>>>>>>>>>>> able to PROVE or actually provide the exact
>>>>>>>>>>>>>>>>>>>>>>> finite algorithm that it used to detemine this fact.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ these
>>>>>>>>>>>>>>>>>>>>>> steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Only if H doesn't abort it simulation.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On the basis that the pure simulation of N steps
>>>>>>>>>>>>>>>>>>>> matches an infinitely repeating pattern embedded_H
>>>>>>>>>>>>>>>>>>>> can correctly determine that this simulated input
>>>>>>>>>>>>>>>>>>>> cannot possibly reach its final state whether or not
>>>>>>>>>>>>>>>>>>>> embedded_H aborts its simulation of this input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> WHAT N Step pattern shows that H^ <H^> is non-halting.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ these
>>>>>>>>>>>>>>>>>> steps would keep repeating:
>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If that is what happens, then obviously H never aborted
>>>>>>>>>>>>>>>>> its simulation, so it CAN'T.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> As soon as embedded_H correctly recognizes this
>>>>>>>>>>>>>>>> infinitely repeating pattern in its correct simulation
>>>>>>>>>>>>>>>> of N steps of its input it is necessarily correct for it
>>>>>>>>>>>>>>>> to report that that its simulated input cannot possibly
>>>>>>>>>>>>>>>> ever reach its halt state.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Only if it proved that it was correct if it does abort
>>>>>>>>>>>>>>> and go to H.Qn, which it can't.
>>>>>>>>>>>>>> With logical entailment the conclusion follows from the
>>>>>>>>>>>>>> premise(s) by logical necessity.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (1) As soon as embedded_H correctly recognizes this
>>>>>>>>>>>>>> infinitely repeating pattern in its correct simulation of
>>>>>>>>>>>>>> N steps of its input
>>>>>>>>>>>>>
>>>>>>>>>>>>> Which makes the falicay of assuming there is a CORRECT
>>>>>>>>>>>>> pattern for H to detect in H^, and that H has the ability
>>>>>>>>>>>>> to detect it.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You are either dishonest or not bright enough to see that
>>>>>>>>>>>> this is a pattern that would be very easy to match, so I
>>>>>>>>>>>> guess I am finally done with you.
>>>>>>>>>>>>
>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ these steps would
>>>>>>>>>>>> keep repeating:
>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>>
>>>>>>>>>>> Which I have proven is NOT a correct pattern if H actually
>>>>>>>>>>> aborts on it and goes to H.Qn.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Yes so it seems that you simply are not bright enough.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> No, you have proved yourself too dishonest to actually try to
>>>>>>>>> prove something, but just continue to make your claims based on
>>>>>>>>> your Fairy Dust powered Unicorns.
>>>>>>>>>
>>>>>>>>
>>>>>>>> If you can't see how obvious that it is that the above pattern
>>>>>>>> infinitely repeats you are not very bright.
>>>>>>>
>>>>>>> And if you can't see that it is only infinitely looping if H
>>>>>>> never aborts, then you are dumber than a door nail.
>>>>>>>
>>>>>>
>>>>>> It is a behavior pattern that conclusively proves that the pure
>>>>>> simulation of the input cannot possibly reach its final state.
>>>>>> Further discussion seems unfruitful.
>>>>>>
>>>>>>
>>>>>
>>>>> No, it only proves that the pure simulation of an H^ built from an
>>>>> H that will NEVER abort is non-halting.
>>>>>
>>>>
>>>> No. It really does prove that the pure simulation of the input
>>>> cannot possibly reach the final state of this simulated input.
>>>>
>>>>
>>>
>>> How? Your trace is ignoring that there is a conditional inside the
>>> copy of H that is in H^.
>>>
>>> Thus, it doesn't meet the requrements for the 'rule' you are trying
>>> to quote, which isn't even written for the case of a simulator but
>>> direct execution, and the replacement of simulation with direct
>>> exection only applies to UNCONDITIONAL simulation.
>>>
>>
>> You just seem to willfully be stupid to understand that a simulating
>> halt decider never determines whether or not its input stops running.
>>
>> Instead it determines whether or not the Linz criteria can possibly be
>> is met:
>>
>> computation that halts … the Turing machine will halt whenever it
>> enters a final state. (Linz:1990:234)
>>
>
> Lying by Double Speak again.
>
> By Definition, A Halt Decider decides if its Input represents a Halting
> Computation, which by definition means does the Computation the input
> represents Halt. This can be equivalently defined as decides if a UTM
> simulating its input will Halt or Not.
>
> To be correct, its answer must match the behavior of that machine.
>
> If you are saying that a "Halt Decider never determines whether or not
> its input stops runnning", then you are simply not talking about
> Computation Theory but just your fancy POOP, so nothing you say matters.
>
> FAIL.
>

On 1/22/2022 7:48 AM, olcott wrote:
> Halting problem undecidability and infinitely nested simulation (V3)

) Ceaseless nonsensical blither.

) Get a brain soon.

) Adios moron.

Coates needs to go to their affiliated University student newspaper and publish their apology for teaching the brainwashed propaganda that a slant cut in single cone is a ellipse when it is in fact a Oval, never the ellipse, for a single cone has only 1 axis of symmetry.

Jill Pipher and Ken Ribet publishing in AMS journal along with Ken Ribet and Jill Pipher their apologies for teaching the mindless conclusion that the slant cut in single cone is a ellipse for in truth it is a Oval, because a single cone has but one axis of symmetry. To get a ellipse requires 2 axes of symmetry such as a cylinder. And that these math professors of AMS are begging the students to forgive them for their mindless math idiocy.

>
>
> Cambridge Math Dept
> Alan Baker, Bela Bollobas, Darwin Smith, John Coates, Timothy Gowers, Peter Johnstone, Imre Leader, Gabriel Paternain
> 
>
> TerenceTao,AndrewWiles, Thomas Hales, Jill Pipher, Ken Ribet, John Stillwell need to go to their affiliated University student newspaper and publish their apology for teaching the brainwashed propaganda that a slant cut in single cone is a ellipse when it is in fact a Oval, never the ellipse, for a single cone has only 1 axis of symmetry.
> >
> > Because they were failures in ever recognizing a slant cut in single cone is a oval, meant they were failures all their life long in mathematics, never realizing that Calculus was geometry, and the Fundamental Theorem of Calculus required a geometry proof, not their mindless dumb and stupid limit-analysis.
> >
> >
> > AP's Proof-Ellipse was never a Conic Section // Math proof series, book 1 Kindle Edition
> > by Archimedes Plutonium (Author)
> >
> > Ever since Ancient Greek Times it was thought the slant cut into a cone is the ellipse. That was false. For the slant cut in every cone is a Oval, never an Ellipse. This book is a proof that the slant cut is a oval, never the ellipse. A slant cut into the Cylinder is in fact a ellipse, but never in a cone.
> >
> > Product details
> > • ASIN ‏ : ‎ B07PLSDQWC
> > • Publication date ‏ : ‎ March 11, 2019
> > • Language ‏ : ‎ English
> > • File size ‏ : ‎ 1621 KB
> > • Text-to-Speech ‏ : ‎ Enabled
> > • Enhanced typesetting ‏ : ‎ Enabled
> > • X-Ray ‏ : ‎ Not Enabled
> > • Word Wise ‏ : ‎ Not Enabled
> > • Print length ‏ : ‎ 20 pages
> > • Lending ‏ : ‎ Enabled
> > •
> > •
> >
> >
> > #11-2, 11th published book
> >
> > World's First Geometry Proof of Fundamental Theorem of Calculus// Math proof series, book 2 Kindle Edition
> > by Archimedes Plutonium (Author)
> >
> > Last revision was 15Dec2021. This is AP's 11th published book of science.
> > Preface:
> > Actually my title is too modest, for the proof that lies within this book makes it the World's First Valid Proof of Fundamental Theorem of Calculus, for in my modesty, I just wanted to emphasis that calculus was geometry and needed a geometry proof. Not being modest, there has never been a valid proof of FTC until AP's 2015 proof. This also implies that only a geometry proof of FTC constitutes a valid proof of FTC.
> >
> > Calculus needs a geometry proof of Fundamental Theorem of Calculus. But none could ever be obtained in Old Math so long as they had a huge mass of mistakes, errors, fakes and con-artist trickery such as the "limit analysis". And very surprising that most math professors cannot tell the difference between a "proving something" and that of "analyzing something". As if an analysis is the same as a proof. We often analyze various things each and every day, but few if none of us consider a analysis as a proof. Yet that is what happened in the science of mathematics where they took an analysis and elevated it to the stature of being a proof, when it was never a proof.
> >
> > To give a Geometry Proof of Fundamental Theorem of Calculus requires math be cleaned-up and cleaned-out of most of math's mistakes and errors. So in a sense, a Geometry FTC proof is a exercise in Consistency of all of Mathematics. In order to prove a FTC geometry proof, requires throwing out the error filled mess of Old Math. Can the Reals be the true numbers of mathematics if the Reals cannot deliver a Geometry proof of FTC? Can the functions that are not polynomial functions allow us to give a Geometry proof of FTC? Can a Coordinate System in 2D have 4 quadrants and still give a Geometry proof of FTC? Can a equation of mathematics with a number that is _not a positive decimal Grid Number_ all alone on the right side of the equation, at all times, allow us to give a Geometry proof of the FTC?
> >
> > Cover Picture: Is my hand written, one page geometry proof of the Fundamental Theorem of Calculus, the world's first geometry proof of FTC, 2013-2015, by AP.
> >
> >
> > Product details
> > ASIN ‏ : ‎ B07PQTNHMY
> > Publication date ‏ : ‎ March 14, 2019
> > Language ‏ : ‎ English
> > File size ‏ : ‎ 1309 KB
> > Text-to-Speech ‏ : ‎ Enabled
> > Screen Reader ‏ : ‎ Supported
> > Enhanced typesetting ‏ : ‎ Enabled
> > X-Ray ‏ : ‎ Not Enabled
> > Word Wise ‏ : ‎ Not Enabled
> > Print length ‏ : ‎ 154 pages
> > Lending ‏ : ‎ Enabled
> > Amazon Best Sellers Rank: #128,729 Paid in Kindle Store (See Top 100 Paid in Kindle Store)
> > #2 in 45-Minute Science & Math Short Reads
> > #134 in Calculus (Books)
> > #20 in Calculus (Kindle Store)
> >
> >
> >
> >
> >
> > #11-3, 24th published book
> >
> > World's First Proof of Kepler Packing Problem KPP // Math proof series, book 3 Kindle Edition
> > by Archimedes Plutonium (Author)
> >
> > There has been a alleged proof of KPP by Thomas Hales, but his is a fakery because he does not define what infinity actually means, for it means a borderline between finite and infinite numbers. Thus, KPP was never going to be proven until a well-defined infinity borderline was addressed within the proof. And because infinity has a borderline means that in free space with no borderlines to tackle and contend with, the 12 kissing point density that is the hexagonal close packed is the maximum density. But the truth and reality of Kepler Packing is asking for maximum packing out to infinity. That means you have to contend and fight with the packing of identical spheres up against a wall or border. And so, in tackling that wall, we can shift the hexagonal closed pack to another type of packing, a hybrid type of packing in order to get "maximum packing". So no proof ever of KPP is going to happen unless the proof tackles a infinity border wall. In free-space, a far distance away from a wall barrier of infinity border, then, hexagonal closed pack reigns and is the packing in all of free space-- but, the moment the packing gets nearby the walls of infinity border, then, we re-arrange the hexagonal closed pack to fit in more spheres. Not unlike us packing a suitcase and then rearranging to fit in more.
> >
> > Cover picture: is a container and so the closed packing must be modified once the border is nearly reached to maximize the number of spheres.
> >
> > Product details
> > • ASIN ‏ : ‎ B07NMV8NQQ
> > • Publication date ‏ : ‎ March 20, 2019
> > • Language ‏ : ‎ English
> > • File size ‏ : ‎ 1241 KB
> > • Text-to-Speech ‏ : ‎ Enabled
> > • Screen Reader ‏ : ‎ Supported
> > • Enhanced typesetting ‏ : ‎ Enabled
> > • X-Ray ‏ : ‎ Not Enabled
> > • Word Wise ‏ : ‎ Not Enabled
> > • Print length ‏ : ‎ 60 pages
> > • Lending ‏ : ‎ Enabled
> >
> > #11-4, 28th published book
> >
> > World's First Valid Proof of 4 Color Mapping Problem// Math proof series, book 4 Kindle Edition
> > by Archimedes Plutonium (Author)
> >
> > Now in the math literature it is alleged that Appel & Haken proved this conjecture that 4 colors are sufficient to color all planar maps such that no two adjacent countries have the same color. Appel & Haken's fake proof was a computer proof and it is fake because their method is Indirect Nonexistence method. Unfortunately in the time of Appel & Haken few in mathematics had a firm grip on true Logic, where they did not even know that Boole's logic is fakery with his 3 OR 2 = 5 with 3 AND 2 = 1, when even the local village idiot knows that 3 AND 2 = 5 with 3 OR 2 = either 3 or 2 depending on which is subtracted. But the grave error in logic of Appel & Haken is their use of a utterly fake method of proof-- indirect nonexistence (see my textbook on Reductio Ad Absurdum). Wiles with his alleged proof of Fermat's Last Theorem is another indirect nonexistence as well as Hales's fake proof of Kepler Packing is indirect nonexistence.
> > Appel & Haken were in a time period when computers used in mathematics was a novelty, and instead of focusing on whether their proof was sound, everyone was dazzled not with the logic argument but the fact of using computers to generate a proof. And of course big big money was attached to this event and so, math is stuck with a fake proof of 4-Color-Mapping. And so, AP starting in around 1993, eventually gives the World's first valid proof of 4-Color-Mapping. Sorry, no computer fanfare, but just strict logical and sound argument.
> >
> > Cover picture: Shows four countries colored yellow, red, green, purple and all four are mutually adjacent. And where the Purple colored country is landlocked, so that if it were considered that a 5th color is needed, that 5th color should be purple, hence, 4 colors are sufficient.
> >
> > Product details
> > ASIN ‏ : ‎ B07PZ2Y5RV
> > Publication date ‏ : ‎ March 23, 2019
> > Language ‏ : ‎ English
> > File size ‏ : ‎ 1183 KB
> > Text-to-Speech ‏ : ‎ Enabled
> > Screen Reader ‏ : ‎ Supported
> > Enhanced typesetting ‏ : ‎ Enabled
> > X-Ray ‏ : ‎ Not Enabled
> > Word Wise ‏ : ‎ Not Enabled
> > Print length ‏ : ‎ 34 pages
> > Lending ‏ : ‎ Enabled
> >
> > #11-5, 6th published book
> >
> > World's First Valid Proofs of Fermat's Last Theorem, 1993 & 2014 // Math proof series, book 5 Kindle Edition
> > by Archimedes Plutonium (Author)
> >
> > Last revision was 29Apr2021. This is AP's 6th published book.
> >
> > Preface:
> > Real proofs of Fermat's Last Theorem// including the fake Euler proof in exp3 and Wiles fake proof.
> >
> > Recap summary: In 1993 I proved Fermat's Last Theorem with a pure algebra proof, arguing that because of the special number 4 where 2 + 2 = 2^2 = 2*2 = 4 that this special feature of a unique number 4, allows for there to exist solutions to A^2 + B^2 = C^2. That the number 4 is a basis vector allowing more solutions to exist in exponent 2. But since there is no number with N+N+N = N*N*N that exists, there cannot be a solution in exp3 and the same argument for higher exponents. In 2014, I went and proved Generalized FLT by using "condensed rectangles". Once I had proven Generalized, then Regular FLT comes out of that proof as a simple corollary. So I had two proofs of Regular FLT, pure algebra and a corollary from Generalized FLT. Then recently in 2019, I sought to find a pure algebra proof of Generalized FLT, and I believe I accomplished that also by showing solutions to Generalized FLT also come from the special number 4 where 2 + 2 = 2^2 = 2*2 = 4. Amazing how so much math comes from the specialness of 4, where I argue that a Vector Space of multiplication provides the Generalized FLT of A^x + B^y = C^z.
> >
> > Cover Picture: In my own handwriting, some Generalized Fermat's Last Theorem type of equations.
> >
> > As for the Euler exponent 3 invalid proof and the Wiles invalid FLT, both are missing a proof of the case of all three A,B,C are evens (see in the text).
> >
> > Product details
> > • ASIN ‏ : ‎ B07PQKGW4M
> > • Publication date ‏ : ‎ March 12, 2019
> > • Language ‏ : ‎ English
> > • File size ‏ : ‎ 1503 KB
> > • Text-to-Speech ‏ : ‎ Enabled
> > • Screen Reader ‏ : ‎ Supported
> > • Enhanced typesetting ‏ : ‎ Enabled
> > • X-Ray ‏ : ‎ Not Enabled
> > • Word Wise ‏ : ‎ Not Enabled
> > • Print length ‏ : ‎ 156 pages
> > • Lending ‏ : ‎ Enabled
> >
> > #11-6, 19th published book
> >
> > World's First Proof of Collatz Conjecture// Math proof series, book 6 Kindle Edition
> > by Archimedes Plutonium (Author)
> >
> > Last revision was 20Aug2021. This is AP's 19th published book.
> >
> > Preface: Old Math's Collatz conjecture, 1937, was this: If you land on an even number, you divide by 2 until you come to an odd number. If you come to or land on an odd number, you do a 3N+1 then proceed further. The conjecture then says that no matter what number you start with, it ends up being 1.
> >
> > What the Collatz proof of math tells us, is that so very often mathematicians pose a conjecture in which their initial formulation of the conjecture is murky, obfuscation and poorly designed statement. Such poorly designed statements can never be proven true or false. An example that comes to mind of another poorly designed conjecture is the No Odd Perfect Conjecture, in which the statement is obfuscation of factors. So for the odd number 9, is it 1+3, or is it 1+ 3 + 3. So when a mathematics conjecture is full of obfuscation and error in the statement, then these type of conjectures never have a proof. And takes a person with a logical mind to fix and straighten out the conjecture statement and then provide a proof, thereof.
> >
> > Cover picture: when I think of Collatz, I think of a slide, a slide down and so my French curve is the best slide I can think of, other than a slide-ruler, but a slide ruler is slide across.
> >
> >
> >
> >
> > Product details
> > • ASIN ‏ : ‎ B07PS98K5H
> > • Publication date ‏ : ‎ March 16, 2019
> > • Language ‏ : ‎ English
> > • File size ‏ : ‎ 1955 KB
> > • Text-to-Speech ‏ : ‎ Enabled
> > • Screen Reader ‏ : ‎ Supported
> > • Enhanced typesetting ‏ : ‎ Enabled
> > • X-Ray ‏ : ‎ Not Enabled
> > • Word Wise ‏ : ‎ Not Enabled
> > • Print length ‏ : ‎ 61 pages
> > • Lending ‏ : ‎ Enabled
> > • Best Sellers Rank: #212,131 in Kindle Store (See Top 100 in Kindle Store)
> > ◦ #4 in 45-Minute Science & Math Short Reads
> > ◦ #9 in Number Theory (Kindle Store)
> > ◦ #32 in Number Theory (Books)
> >
> >
> >
> >
> > #11-7, 20th published book
> > World's First Proofs that No Perfect Cuboid Exists// Math proof series, book 7 Kindle Edition
> > by Archimedes Plutonium (Author)
> >
> > Someone on the Internet posed the unproven No Perfect Cuboid, and so I took up the challenge. I am usually a sucker for geometry riddles, more so than number theory. So I obliged. Then by 2014 I proved the matter and looking back at it now in 2019, I really really do not see what all the fuss was about-- that it was not that hard not hard at all. You just have to look carefully at sets of 4 right triangles and find an Impossibility Construction, why you cannot have those 4 right triangles all with positive integer numbers for their 3 sides. But the proof method is so hugely important in math-- impossibility of construction. And, please, do not confuse that method with Reductio Ad Absurdum, for RAA is not a valid proof method in mathematics (see my logic book on RAA). But, the method of Impossible Construction, although it might look like RAA, is totally different and fully valid in all aspects.
> >
> > But now, in hindsight in March 2019, writing this up, I see a very close connection of No Perfect Cuboid to that of Generalized Fermat's Last Theorem with its equation of A^x + B^y = C^z and the way I proved Generalized FLT was with "condensed rectangles" and the No Perfect Cuboid is a 3rd Dimension object but it is 4 rectangles of 4 right triangles we inspect. And we can pursue that connection between Generalized FLT and No Perfect Cuboid further, but not now.
> >
> > Cover Picture: Is that of 4 rectangular boxes, 2 of which are cubes sitting atop a book page of the Cubic Set for the Transuranium Atoms, from the textbook "The Elements Beyond Uranium" , Seaborg, Loveland, 1990. I am always looking for connections.
> >
> >
> > Product details
> > • ASIN ‏ : ‎ B07PMZQNNT
> > • Publication date ‏ : ‎ March 16, 2019
> > • Language ‏ : ‎ English
> > • File size ‏ : ‎ 1382 KB
> > • Text-to-Speech ‏ : ‎ Enabled
> > • Screen Reader ‏ : ‎ Supported
> > • Enhanced typesetting ‏ : ‎ Enabled
> > • X-Ray ‏ : ‎ Not Enabled
> > • Word Wise ‏ : ‎ Not Enabled
> > • Print length ‏ : ‎ 61 pages
> > • Lending ‏ : ‎ Enabled
> >
> >
> >
> >
> >
> >
> >
> > #11-8, 21st published book
> >
> > World's First Proofs of Mathematics Oldest Unsolved Problems: No Odd Perfect and Finiteness of Perfect Numbers // Math proof series, book 8 Kindle Edition
> > by Archimedes Plutonium (Author)
> >
> > Last revision was 26Apr2021. And this is AP's 21st published book.
> >
> > Preface: Now my history with these proofs goes back to 1991 to 1993, and have been finessing the proofs ever since. Some math proofs just nag nag and nag you. They just cannot be settled still. Their proof is a tiny tiny sliver of impossibility that is easily overlooked. Like an optical illusion that you are mislead into, or like those pictures where you look at it one way and you see a young lady and another way you see a very old lady.
> >
> > Now the No Odd Perfect Number is not a important proof in mathematics but mostly a spectacle for it does not teach much beyond making proper correct definitions. And murky definitions is what held a proof of No Odd Perfect, other than 1, held it back. The murky definition of factors, do we include 1 or not include, for example the odd number 9, do we include 3 twice or once for that we have 1* 9 and we have 3*3 and Old Math looked at that as 1 + 3, whereas I would look at that as 1 + 3 + 3. So when you have messy definitions, murky and messy, of course no proof will be found in over 2,000 years.
> >
> > Cover Picture: Shows our modern day new reality of the situation where the definition of "perfect" was a Ancient Greek idea, steeped in murky messy idea of factors and when to add factors, that no longer is suitable for mathematics.
> >
> > Product details
> > • ASIN ‏ : ‎ B07PN1CPRP
> > • Publication date ‏ : ‎ March 16, 2019
> > • Language ‏ : ‎ English
> > • File size ‏ : ‎ 1534 KB
> > • Text-to-Speech ‏ : ‎ Enabled
> > • Enhanced typesetting ‏ : ‎ Enabled
> > • X-Ray ‏ : ‎ Not Enabled
> > • Word Wise ‏ : ‎ Not Enabled
> > • Print length ‏ : ‎ 28 pages
> > • Lending ‏ : ‎ Enabled
> >
> >
> > #11-9, 15th published book
> >
> > World's First Proofs of Infinitude of Twin-Primes, and Polignac Proved // Math proof series, book 9 Kindle Edition
> > by Archimedes Plutonium (Author)
> >
> > Circa 1991-1993, I gave an Old Math style of proof for the Infinitude of Twin Primes, modeling my proof as to a Euclid Infinitude of Primes Proof. But then came year 2009 when I found the way to make Infinity concept well-defined. Up until 2009, no-one in the world had a clear precise definition or understanding of what "infinity" was or what it means. It means a borderline between finite and infinite and the way to find this borderline is to use the Tractrix when the unit-tractrix area catches up with the area inside a unit circle is the infinity borderline and it happens to be when pi digits have three zeroes in a row, does the tractrix area equal the circle area-- hence, we reached infinity border and beyond are infinite numbers, no longer finite numbers. What that discovery does for proofs of infinitude is change all those proofs dramatically. And here in Twin-Primes and Polignac I show the reader how modern day New Math proves infinitude of any set of numbers.
> >
> >
> > Cover Picture: Is a picture of the first five twin-primes.
> >
> > Product details
> > ASIN ‏ : ‎ B07PMY1YWB
> > Publication date ‏ : ‎ March 15, 2019
> > Language ‏ : ‎ English
> > File size ‏ : ‎ 1642 KB
> > Text-to-Speech ‏ : ‎ Enabled
> > Screen Reader ‏ : ‎ Supported
> > Enhanced typesetting ‏ : ‎ Enabled
> > X-Ray ‏ : ‎ Not Enabled
> > Word Wise ‏ : ‎ Not Enabled
> > Print length ‏ : ‎ 9 pages
> > Lending ‏ : ‎ Enabled
> >
> > #11-10, 16th published book
> >
> > World's First Proofs of Goldbach, Legendre, Staircase Conjectures// Math proof series, book 10 Kindle Edition
> > by Archimedes Plutonium (Author)
> >
> > AP proved the Goldbach Conjecture starting 1993 where the Algebra Columns is the bedrock-key of the proof involved. The Algebra Column Array is the tool and no-one was going to prove Goldbach unless they had that tool, which the 2014 post of mine makes the array tool crystal clear. So starting 1993, I posted to sci.math about Array or Algebra Column which as a tool would render all proofs of this nature. The Goldbach conjecture historically dates back to 1742, and the Legendre conjecture dates 1752-1833. The Staircase conjecture is a wholly new conjecture proposed by AP circa 2016.
> >
> > Cover: Is a Algebra Column Array sequence starting with 6 Array and then 8 Array.
> >
> > Product details
> > • ASIN ‏ : ‎ B07PS6MR48
> > • Publication date ‏ : ‎ March 15, 2019
> > • Language ‏ : ‎ English
> > • File size ‏ : ‎ 1740 KB
> > • Text-to-Speech ‏ : ‎ Enabled
> > • Screen Reader ‏ : ‎ Supported
> > • Enhanced typesetting ‏ : ‎ Enabled
> > • X-Ray ‏ : ‎ Not Enabled
> > • Word Wise ‏ : ‎ Not Enabled
> > • Print length ‏ : ‎ 36 pages
> > • Lending ‏ : ‎ Enabled
> > Amazon Best Sellers Rank: #148,852 Paid in Kindle Store (See Top 100 Paid in Kindle Store)
> > #4 in Number Theory (Kindle Store)
> > #38 in Number Theory (Books)
> > #7 in One-Hour Science & Math Short Reads
> > 

> >
> > #11-11, 25th published book
> >
> > Disproof of Riemann Hypothesis // Math proof series, book 11 Kindle Edition
> > by Archimedes Plutonium (Author)
> >
> > Last revision was 31Oct2021. This is AP's 25th book of science.
> >
> > Preface: The Riemann Hypothesis was a conjecture never able to be proven and for good reason, for it was the last symptom of a rampant disease inside of mathematics. Old Math did not have the true numbers that compose mathematics. Old Math had a rag-tag ugly collection of fake numbers with their Reals, their Negative numbers compounded with Rationals compounded with Irrationals and then adding on the Imaginary. These are fake numbers, when the true numbers of mathematics are the Decimal Grid Numbers. Because Old Math uses fake numbers, is the reason that Riemann Hypothesis just languished, languished and languished. You cannot prove something riddled in fakery. Below I demonstrate why having fake numbers in math, creates fake proofs, fake theorems, and creates a conjecture that can never be proven.
> >
> > Cover picture: Riemann Hypothesis deals with fake numbers of mathematics. When what is needed is the true numbers-- Decimal Grid Numbers. We learn Decimal Grid Numbers when very young, when just toddlers, wood counting blocks. All the true numbers of mathematics come from Mathematical Induction-- counting. Mathematical Induction is utterly absent in the Riemann Hypothesis, when it should be central to the hypothesis.
> > Length: 58 pages
> >
> > Product details
> > ASIN ‏ : ‎ B07PVDS1RC
> > Publication date ‏ : ‎ March 20, 2019
> > Language ‏ : ‎ English
> > File size ‏ : ‎ 1475 KB
> > Text-to-Speech ‏ : ‎ Enabled
> > Screen Reader ‏ : ‎ Supported
> > Enhanced typesetting ‏ : ‎ Enabled
> > X-Ray ‏ : ‎ Not Enabled
> > Word Wise ‏ : ‎ Not Enabled
> > Print length ‏ : ‎ 58 pages
> > Lending ‏ : ‎ Enabled
> > Best Sellers Rank: #5,118,638 in Kindle Store (See Top 100 in Kindle Store)
> > ◦ #643 in Number Theory (Kindle Store)
> > ◦ #1,398 in One-Hour Science & Math Short Reads
> > ◦ #3,559 in Number Theory (Books)
> > 

> > #11-12, 152nd published book
> > The 6th Regular Polyhedron-- hexagonal faces at infinity// Math proof series, book 12
> > by Archimedes Plutonium (Author) Format: Kindle Edition
> >
> > Last revision was 10Dec2021. And this is AP's 152nd published book of science.
> > Preface: This is my 152nd book of science an exciting book, and it came out of the clear blue. The writing of it took a mere week's time and it is a byproduct of my 151st book of science, TEACHING TRUE PHYSICS, 1st year College. Although my 151st book took me over a year to write; this book took just 1 week to write. Difference being that of a textbook versus that of a book on a specific topic, is 50 times more difficult because a textbook takes so much time in organizing, order, and fitting together pieces of each chapter in fact, whereas a single topic science book is like writing a prose story and is 50 times easier to write than a textbook.
> > While I was doing 151st, I noticed and emphasized that all of physics is determined by 6 laws of physics, and the first principle of physics is All is Atom and Atoms are nothing but electricity and magnetism. Then we notice that 6 laws cover all of physics, 6 laws of electricity and magnetism. We notice that all of logic and math is covered by 6 operators. And then we look at geometry's regular polyhedrons and find there are only 5 known regular polyhedron with a proof in Old Math that a 6th Regular Polyhedron cannot exist. An actual proof in Old Math that a 6th cannot exist.
> > Well, AP knows better. For AP knows that if all of Physics is written in the language of just 6 laws and all of logic and mathematics are covered by 6 operators. That AP knows Old Math made a mistake in thinking they proved 5 regular polyhedron were all that exist as regular polyhedron. So Old Math made some or several mistakes in their so called proof that 5 and only 5 regular polyhedron exist, and that is what this book covers, the 6th regular polyhedron of the world, what it is, and what it looks like.
> > Warning: the entire book is written from a sequential dated notebook, so if you read something early on, I may have changed my mind on the idea near the end. This is not a textbook, but a notebook of discovery and read it for its history.
> > Cover Picture: is my iphone photograph of a soccer ball of 20 hexagons, 12 pentagons; and a glass ball covered by netting of tiny hexagons. Both objects I use in experiments of proving the 6th Regular Polyhedron.
> >
> >
> > Product details
> > • ASIN ‏ : ‎ B09K4PWKVK
> > • Publication date ‏ : ‎ October 21, 2021
> > • Language ‏ : ‎ English
> > • File size ‏ : ‎ 839 KB
> > • Text-to-Speech ‏ : ‎ Enabled
> > • Screen Reader ‏ : ‎ Supported
> > • Enhanced typesetting ‏ : ‎ Enabled
> > • X-Ray ‏ : ‎ Not Enabled
> > • Word Wise ‏ : ‎ Enabled
> > • Print length ‏ : ‎ 76 pages
> > • Lending ‏ : ‎ Enabled
> >
> > #11-13, 160th published book
> >
> > MATHOPEDIA-- List of 76 fakes and mistakes of Old Math// Student teaches professor Kindle Edition
> > by Archimedes Plutonium (Author)
> >
> > Preface:
> > A Mathopedia is like a special type of encyclopedia on the subject of mathematics. It is about the assessment of the worth of mathematics and the subject material of mathematics. It is a overall examination and a evaluation of mathematics and its topics.
> >
> > The ordering of Mathopedia is not a alphabetic ordering, nor does it have a index. The ordering is purely that of importance at beginning and importance at end.
> >
> > The greatest use of Mathopedia is a guide to students of what not to waste your time on and what to focus most of your time. I know so many college classes in mathematics are just a total waste of time, waste of valuable time for the class is math fakery. I know because I have been there.
> >
> > Now I am going to cite various reference sources of AP books if anyone wants more details and can be seen in the Appendix at the end of the book.
> >
> > I suppose, going forward, mathematics should always have a mathopedia, where major parts of mathematics as a science are held under scrutiny and question as to correctness. In past history we have called these incidents as "doubters of the mainstream". Yet math, like physics, can have no permanent mainstream, since there is always question of correctness in physics, there then corresponds question of correctness in mathematics (because math is a subset of physics). What I mean is that each future generation corrects some mistakes of past mathematics. If anyone is unsure of what I am saying here, both math and physics need constant correcting, never belonged in science. This then converges with the logic-philosophy of Pragmatism (see AP's book of logic on Pragmatism).
> >
> > Product details
> > • ASIN ‏ : ‎ B09MZTLRL5
> > • Publication date ‏ : ‎ December 2, 2021
> > • Language ‏ : ‎ English
> > • File size ‏ : ‎ 1147 KB
> > • Text-to-Speech ‏ : ‎ Enabled
> > • Screen Reader ‏ : ‎ Supported
> > • Enhanced typesetting ‏ : ‎ Enabled
> > • X-Ray ‏ : ‎ Not Enabled
> > • Word Wise ‏ : ‎ Not Enabled
> > • Print length ‏ : ‎ 62 pages

> > • Lending ‏ : ‎ Enabled
> >
> >
> >
> >
> > y z
> > | /
> > | /
> > |/______ x
> >
> > More people reading and viewing AP's newsgroup than viewing sci.math, sci.physics. So AP has decided to put all NEW WORK, to his newsgroup. And there is little wonder because in AP's newsgroups, there is only solid pure science going on, not a gang of hate spewing misfits blighting the skies.
> >
> > In sci.math, sci.physics there is only stalking hate spew along with Police Drag Net Spam of no value and other than hate spew there is Police drag net spam day and night.
> >
> > I re-opened the old newsgroup PAU of 1990s and there one can read my recent posts without the hassle of stalkers and spammers, Police Drag Net Spam that floods each and every day, book and solution manual spammers, off-topic-misfits, front-page-hogs, churning imbeciles, stalking mockers, suppression-bullies, and demonizers. And the taxpayer funded hate spew stalkers who ad hominem you day and night on every one of your posts.
> >
> > There is no discussion of science in sci.math or sci.physics, just one long line of hate spewing stalkers followed up with Police Drag Net Spam (easy to spot-- very offtopic-- with hate charged content). And countries using sci.physics & sci.math as propaganda platforms, such as tampering in elections with their mind-rot.
> >
> > Read my recent posts in peace and quiet.
> > https://groups.google.com/forum/?hl=en#!forum/plutonium-atom-universe
> > Archimedes Plutonium

On 1/25/2022 5:43 PM, Richard Damon wrote:
> On 1/25/22 9:44 AM, olcott wrote:
>> On 1/25/2022 5:55 AM, Richard Damon wrote:
>>> On 1/25/22 12:27 AM, olcott wrote:
>>>> On 1/24/2022 11:15 PM, Richard Damon wrote:
>>>>>
>>>>> On 1/25/22 12:04 AM, olcott wrote:
>>>>>> On 1/24/2022 10:54 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 1/24/22 11:28 PM, olcott wrote:
>>>>>>>> On 1/24/2022 10:25 PM, Richard Damon wrote:
>>>>>>>>> On 1/24/22 11:19 PM, olcott wrote:
>>>>>>>>>> On 1/24/2022 10:16 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/24/22 10:58 PM, olcott wrote:
>>>>>>>>>>>> On 1/24/2022 9:50 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/24/22 10:45 PM, olcott wrote:
>>>>>>>>>>>>>> On 1/24/2022 8:26 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 1/24/22 9:11 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 1/24/2022 8:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 1/24/22 8:32 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 1/24/2022 6:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 1/24/22 7:09 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 1/24/2022 5:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 1/24/22 10:03 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 10:45 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 11:17 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 9:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 10:40 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 9:24 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 10:10 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 8:42 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 9:29 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 8:14 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 9:03 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 7:55 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 8:10 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 7:00 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 7:25 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 6:09 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 7:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 5:50 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 6:16 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 5:06 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 5:47 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 4:40 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 5:18 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 4:01 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 4:40 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 2:25 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 2:19 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 10:43 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 11:34 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 3:36 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 4:25 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 3:20
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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'.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Anyone that knows that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> x86 language can tell
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its easy to match
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the infinite loop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fa](01)  55
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fb](02)  8bec
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fd](02)  ebfe
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> jmp 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015ff](01)  5d pop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001600](01)  c3 ret
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0007)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001600]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fa][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fb][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fd][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebfe jmp 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fd][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebfe jmp 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Showing that you can do
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> one case does not prove
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the same method
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> works on all,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> particularly harder
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> methods.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is just you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> serving Red Herring.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And that pattern does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> NOT show up in the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation by H of H^
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Which makes it MORE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> lies by Red Herring.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Total lack of proof.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does the proof
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> include the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> posibility that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input includes a copy
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the decider?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is always the case
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that a simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider can correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> base its halt status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decision on the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> LIE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Proven incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H -> H.Qn then H^ ->
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^.Qn and Halts and for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^ <H^> proves H wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We know that this must
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be true because we
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> know that the pure UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Turing Machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> description is defined
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to have equivalent
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior to that of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the direct execution
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the same machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, but that does't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove what you sy.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are just LYING out
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of your POOP.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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 is not answering
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the question: Does the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input stop running?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU need to answer,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> which H are you using?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H doesn't abort,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then H^ is non-halting,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but H will never answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H does abort and go
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H.Qn, then the pure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WILL halt at H^.Qn, so
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H was wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is answering the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Would the pure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input ever stop running?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, and if H -> H.Qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it will.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU JUST AREN'T BRIGHT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ENOUGH TO GET THIS. IT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> CAN BE VERIFIED AS
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> COMPLETELY TRUE ENTIRELY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ON THE BASIS OF THE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> MEANING OF ITS WORDS.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is the case that if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H recognizes an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely repeating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern in the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> such that this correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state then this is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete prove that this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If it COULD CORRECTLY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recognize an infinitely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeating pattern in its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation that can not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state (when simulated by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a UTM, not just H) then,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YES, H can go to H.Qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The problem is that due
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to 'pathological
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-reference' in H^,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ANY pattern that H sees
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in its simulation of <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <H^> that it transitions
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H.Qn, will BY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DEFINITION, become a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So a correctly simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT that cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches its final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> anyway. YOU ARE DUMBER
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THAN A BOX OF ROCKS !!!
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That's not what I said, I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> said there is no pattern
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H use to detect that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it won't halt, as any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern that H uses to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decide to go to H.Qn will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be WRONG for H^ as if H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> goes to H.Qn, then H^ also
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> goes to H^.Qn and Halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When the correctly simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT to embedded_H cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state it is necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct for embedded_H to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report that its correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right,  but you have only
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proved that H^ is non-halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for the case where H doesn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because you are dumber than a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> box of rocks (or perhaps you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are a bot?)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You did not notice that I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never mentioned the word:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "halting".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For a human being you are much
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dumber than a box of rocks.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For a bot you did quite well
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (you nearly passed the Turing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> test) it took me this long to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> realize that you are not a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> human being.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But reaching final state is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same as Halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have only prove that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pure simulation of the input to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H never reaches a final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for case when H doesn't abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You deliberate weasel words do
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not apply to what I said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Premise: When the correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT to embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) Conclusion: It is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H to report that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated INPUT cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And the correct simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H is determined by the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM, not H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) is a logical consequence of (1).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is logically incorrect to argue
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> with a deductive logical premise.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But 1 is only true if H doesn't go
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H.Qn, so H can't correctly go to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H.Qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are quite the deceiver making
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sure to always change the subject
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> rather than directly address the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> point at hand.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you seem quite dense. I did NOT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> change the subject, I pointed out an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> error in your statement. You seem to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be unable to comprehend that.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) logically follows from (1) is true.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But 1 ISN'T True if H <H^> <H^> ->
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H.Qn, as the correctly simulate input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When testing whether or not one
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> assertion logically follows from
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> another the premises are always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "given" to be true even if they are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> false.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Don't know what sort of logic you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> claiming.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And arguemnt with a false premise is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unsound.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We are not yet looking at soundness we
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are looking at validity.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is true that (2) logically follows
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from (1).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We can't move on from this one point
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> until we have mutual agreement.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Very strange then, why are you arguing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about that which was accepted unless you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disagree to the conditions that they were
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> accepted under?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It has long been accepted that the under
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the hypothetical condition where H can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually determine that the UTM will run
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> forever, it is correct (and in fact
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> needed to be correct) for H to go to H.Qn
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and say non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> OKAY so then you agree with this?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Premise: When the correctly simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT to embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly reach its final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) Conclusion: It is necessarily correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for embedded_H to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report that its correctly simulated INPUT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Under the definition that 'correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input' is as determined by a UTM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not H (if it aborts its simulation).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is only stipulated to be correct other
>>>>>>>>>>>>>>>>>>>>>>>>>>>> details are currently unspecified.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> That isn't a 'stipulation', that is a
>>>>>>>>>>>>>>>>>>>>>>>>>>> DEFINITION.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> This is obviously your attempt at being a
>>>>>>>>>>>>>>>>>>>>>>>>>>> weasel.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> The DEFINITION of correct simulation is the
>>>>>>>>>>>>>>>>>>>>>>>>>>> results of a UTM simulating the input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Any deviaiton in this means you are just
>>>>>>>>>>>>>>>>>>>>>>>>>>> eating your POOP.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It also does not presume that H CAN
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determine that this condition exists, so it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would be correct, but H might not be able
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to decide to do so. So it may be correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for it to do so, but it might not actually
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be able to do it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> There is also the case you tend to ignore
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you start with an H that is defined to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> NOT abort, but you try to use (2) to claim
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it now can abort, the H is (2) must be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same H that the H^ in (1) was built form
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All of these restrictions are actually in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the actual meaning of the words you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> using, from the context of the problem, but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I state them because knowing you, you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> going to try to break that restrictions.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> This seems to be the very first time that
>>>>>>>>>>>>>>>>>>>>>>>>>>>> you actually paid close attention, good jo
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> As I asked, how is that different from the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> statement of the requirements on H?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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 its simulated input would never reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>> its own final state. In this case H aborts
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation of this input and transitions
>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H.qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Note, The correct answer is NOT based on a
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of N steps, but a simulation by a
>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM which will run until it halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> H needs to make ITS decision on the limited N
>>>>>>>>>>>>>>>>>>>>>>>>>>> step, so it needs to prove that its answer
>>>>>>>>>>>>>>>>>>>>>>>>>>> matches.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Remember, when we do this run, H is defined,
>>>>>>>>>>>>>>>>>>>>>>>>>>> and thus N is a SPECIFIC number, not an
>>>>>>>>>>>>>>>>>>>>>>>>>>> 'arbitrary' number.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You also will need to some how prove that a
>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern exists in N steps that correct
>>>>>>>>>>>>>>>>>>>>>>>>>>> dectect non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> This has been previously shown to be
>>>>>>>>>>>>>>>>>>>>>>>>>>> impossible, so you need to actually come up
>>>>>>>>>>>>>>>>>>>>>>>>>>> with it or show an actual error in the proof.
>>>>>>>>>>>>>>>>>>>>>>>>>>> You can't just assume it exists.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Great we can move to the next step:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Premise: When embedded_H correctly
>>>>>>>>>>>>>>>>>>>>>>>>>> determines its simulated INPUT to
>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H cannot possibly reach its final state
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> (2) Conclusion: It is necessarily correct for
>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H to report that its correctly
>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT cannot possibly reach its
>>>>>>>>>>>>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> WARNING, you are getting way into hypothecctica
>>>>>>>>>>>>>>>>>>>>>>>>> Unicoprn Terretory, but lets unpack this
>>>>>>>>>>>>>>>>>>>>>>>>> statement.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> IF H can correctly deteremine (that means that
>>>>>>>>>>>>>>>>>>>>>>>>> there needs to exist a finite algroithm to
>>>>>>>>>>>>>>>>>>>>>>>>> determine this case, and that this result
>>>>>>>>>>>>>>>>>>>>>>>>> matches the behavior demonstrated by the
>>>>>>>>>>>>>>>>>>>>>>>>> definitional UTM simulataion of this input),
>>>>>>>>>>>>>>>>>>>>>>>>> that the input will NEVER reach it final state,
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Then yes, it is correct for H to report that
>>>>>>>>>>>>>>>>>>>>>>>>> its input can not possible reach its final state.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Great we have finally begun an honest dialogue.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Note, that if H does this, then the proof that
>>>>>>>>>>>>>>>>>>>>>>>>> the input never reached its final state must
>>>>>>>>>>>>>>>>>>>>>>>>> have included that fact that the copy of H
>>>>>>>>>>>>>>>>>>>>>>>>> inside H^ will also do the exact same thing
>>>>>>>>>>>>>>>>>>>>>>>>> with the exact same input.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Also, to show the premise is True, you need to
>>>>>>>>>>>>>>>>>>>>>>>>> be able to PROVE or actually provide the exact
>>>>>>>>>>>>>>>>>>>>>>>>> finite algorithm that it used to detemine this
>>>>>>>>>>>>>>>>>>>>>>>>> fact.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>> these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Only if H doesn't abort it simulation.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> On the basis that the pure simulation of N steps
>>>>>>>>>>>>>>>>>>>>>> matches an infinitely repeating pattern embedded_H
>>>>>>>>>>>>>>>>>>>>>> can correctly determine that this simulated input
>>>>>>>>>>>>>>>>>>>>>> cannot possibly reach its final state whether or
>>>>>>>>>>>>>>>>>>>>>> not embedded_H aborts its simulation of this input.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> WHAT N Step pattern shows that H^ <H^> is non-halting.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ these
>>>>>>>>>>>>>>>>>>>> steps would keep repeating:
>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If that is what happens, then obviously H never
>>>>>>>>>>>>>>>>>>> aborted its simulation, so it CAN'T.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> As soon as embedded_H correctly recognizes this
>>>>>>>>>>>>>>>>>> infinitely repeating pattern in its correct simulation
>>>>>>>>>>>>>>>>>> of N steps of its input it is necessarily correct for
>>>>>>>>>>>>>>>>>> it to report that that its simulated input cannot
>>>>>>>>>>>>>>>>>> possibly ever reach its halt state.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Only if it proved that it was correct if it does abort
>>>>>>>>>>>>>>>>> and go to H.Qn, which it can't.
>>>>>>>>>>>>>>>> With logical entailment the conclusion follows from the
>>>>>>>>>>>>>>>> premise(s) by logical necessity.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (1) As soon as embedded_H correctly recognizes this
>>>>>>>>>>>>>>>> infinitely repeating pattern in its correct simulation
>>>>>>>>>>>>>>>> of N steps of its input
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Which makes the falicay of assuming there is a CORRECT
>>>>>>>>>>>>>>> pattern for H to detect in H^, and that H has the ability
>>>>>>>>>>>>>>> to detect it.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You are either dishonest or not bright enough to see that
>>>>>>>>>>>>>> this is a pattern that would be very easy to match, so I
>>>>>>>>>>>>>> guess I am finally done with you.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ these steps
>>>>>>>>>>>>>> would
>>>>>>>>>>>>>> keep repeating:
>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>
>>>>>>>>>>>>> Which I have proven is NOT a correct pattern if H actually
>>>>>>>>>>>>> aborts on it and goes to H.Qn.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Yes so it seems that you simply are not bright enough.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> No, you have proved yourself too dishonest to actually try to
>>>>>>>>>>> prove something, but just continue to make your claims based
>>>>>>>>>>> on your Fairy Dust powered Unicorns.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> If you can't see how obvious that it is that the above pattern
>>>>>>>>>> infinitely repeats you are not very bright.
>>>>>>>>>
>>>>>>>>> And if you can't see that it is only infinitely looping if H
>>>>>>>>> never aborts, then you are dumber than a door nail.
>>>>>>>>>
>>>>>>>>
>>>>>>>> It is a behavior pattern that conclusively proves that the pure
>>>>>>>> simulation of the input cannot possibly reach its final state.
>>>>>>>> Further discussion seems unfruitful.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> No, it only proves that the pure simulation of an H^ built from
>>>>>>> an H that will NEVER abort is non-halting.
>>>>>>>
>>>>>>
>>>>>> No. It really does prove that the pure simulation of the input
>>>>>> cannot possibly reach the final state of this simulated input.
>>>>>>
>>>>>>
>>>>>
>>>>> How? Your trace is ignoring that there is a conditional inside the
>>>>> copy of H that is in H^.
>>>>>
>>>>> Thus, it doesn't meet the requrements for the 'rule' you are trying
>>>>> to quote, which isn't even written for the case of a simulator but
>>>>> direct execution, and the replacement of simulation with direct
>>>>> exection only applies to UNCONDITIONAL simulation.
>>>>>
>>>>
>>>> You just seem to willfully be stupid to understand that a simulating
>>>> halt decider never determines whether or not its input stops running.
>>>>
>>>> Instead it determines whether or not the Linz criteria can possibly
>>>> be is met:
>>>>
>>>> computation that halts … the Turing machine will halt whenever it
>>>> enters a final state. (Linz:1990:234)
>>>>
>>>
>>> Lying by Double Speak again.
>>>
>>> By Definition, A Halt Decider decides if its Input represents a
>>> Halting Computation, which by definition means does the Computation
>>> the input represents Halt. This can be equivalently defined as
>>> decides if a UTM simulating its input will Halt or Not.
>>>
>>> To be correct, its answer must match the behavior of that machine.
>>>
>>> If you are saying that a "Halt Decider never determines whether or
>>> not its input stops runnning", then you are simply not talking about
>>> Computation Theory but just your fancy POOP, so nothing you say matters.
>>>
>>> FAIL.
>>>
>>
>> Since I told you this hundreds of times you are very willfully very
>> stupid:
>>
>> Simulating halt deciders never determine whether or not their input
>> stops running. Every input to a simulating halt decider always stops
>> running either because it reached its final state or its simulation
>> was aborted. Simulating halt deciders determine whether or not the
>> Linz criteria can possibly be met: computation that halts … the Turing
>> machine will halt whenever it enters a final state. (Linz:1990:234)
>>
>>
>
> Then you aren't working on the HALTING problem because that is based on
> HALITNG of the computation being asked about.

On 1/25/2022 6:17 PM, Richard Damon wrote:
>
> On 1/25/22 7:03 PM, olcott wrote:
>> On 1/25/2022 5:43 PM, Richard Damon wrote:
>>> On 1/25/22 9:44 AM, olcott wrote:
>>>> On 1/25/2022 5:55 AM, Richard Damon wrote:
>>>>> On 1/25/22 12:27 AM, olcott wrote:
>>>>>> On 1/24/2022 11:15 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 1/25/22 12:04 AM, olcott wrote:
>>>>>>>> On 1/24/2022 10:54 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 1/24/22 11:28 PM, olcott wrote:
>>>>>>>>>> On 1/24/2022 10:25 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/24/22 11:19 PM, olcott wrote:
>>>>>>>>>>>> On 1/24/2022 10:16 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/24/22 10:58 PM, olcott wrote:
>>>>>>>>>>>>>> On 1/24/2022 9:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 1/24/22 10:45 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 1/24/2022 8:26 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 1/24/22 9:11 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 1/24/2022 8:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 1/24/22 8:32 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 1/24/2022 6:50 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 1/24/22 7:09 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 1/24/2022 5:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 1/24/22 10:03 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 10:45 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 11:17 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 9:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 10:40 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 9:24 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 10:10 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 8:42 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 9:29 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 8:14 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 9:03 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 7:55 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 8:10 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 7:00 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 7:25 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 6:09 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 7:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 5:50 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 6:16 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 5:06 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 5:47 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 4:40 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 5:18 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 4:01 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 4:40 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/2022 2:25 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/23/22 2:19 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 10:43 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 11:34 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 3:36
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/22 4:25 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 1/22/2022 3:20
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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'.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Anyone that knows
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that x86 language
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can tell that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> easy to match the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite loop pattern:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fa](01)  55
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fb](02)  8bec
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015fd](02)  ebfe
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> jmp 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000015ff](01)  5d
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pop ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001600](01)  c3 ret
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0007)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001600]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fa][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fb][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fd][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebfe jmp 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ---[000015fd][002126f0][002126f4]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ebfe jmp 000015fd
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Showing that you can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do one case does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove that the same
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> method works on all,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> particularly harder
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> methods.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is just you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> serving Red Herring.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And that pattern does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> NOT show up in the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation by H of H^
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Which makes it MORE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> lies by Red Herring.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Total lack of proof.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does the proof
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> include the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> posibility that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input includes a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> copy of the decider?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is always the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> case that a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly base its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt status decision
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on the behavior pure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> LIE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Proven incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H -> H.Qn then H^
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> -> H^.Qn and Halts
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and for H^ <H^>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proves H wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We know that this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must be true because
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> we know that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pure UTM simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of an Turing Machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> description is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> defined to have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> equivalent behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to that of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> direct execution of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, but that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does't prove what you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sy.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are just LYING
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> out of your POOP.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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 is not answering
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the question: Does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input stop running?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU need to answer,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> which H are you using?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H doesn't abort,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then H^ is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting, but H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will never answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H does abort and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> go to H.Qn, then the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pure simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input WILL halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> at H^.Qn, so H was
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is answering the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Would the pure
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input ever stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, and if H ->
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H.Qn it will.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU JUST AREN'T BRIGHT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ENOUGH TO GET THIS. IT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> CAN BE VERIFIED AS
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> COMPLETELY TRUE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ENTIRELY ON THE BASIS
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> OF THE MEANING OF ITS
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WORDS.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is the case that if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H recognizes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an infinitely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> repeating pattern in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input such that this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then this is complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove that this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If it COULD CORRECTLY
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recognize an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinitely repeating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern in its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation that can not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state (when
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by a UTM, not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just H) then, YES, H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can go to H.Qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The problem is that due
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to 'pathological
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-reference' in H^,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ANY pattern that H sees
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in its simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <H^> <H^> that it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> transitions to H.Qn,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will BY DEFINITION,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> become a halting pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So a correctly simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT that cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state reaches its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state anyway. YOU ARE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DUMBER THAN A BOX OF
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ROCKS !!!
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That's not what I said, I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> said there is no pattern
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H use to detect that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it won't halt, as any
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern that H uses to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decide to go to H.Qn will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be WRONG for H^ as if H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> goes to H.Qn, then H^
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> also goes to H^.Qn and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When the correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final state it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is necessarily correct for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H to report that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its correctly simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right,  but you have only
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proved that H^ is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting for the case
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> where H doesn't abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because you are dumber than
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a box of rocks (or perhaps
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are a bot?)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You did not notice that I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never mentioned the word:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "halting".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For a human being you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> much dumber than a box of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> rocks.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For a bot you did quite well
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (you nearly passed the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Turing test) it took me this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> long to realize that you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not a human being.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But reaching final state is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same as Halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have only prove that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pure simulation of the input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H never reaches a final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state for case when H doesn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You deliberate weasel words do
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not apply to what I said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Premise: When the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated INPUT to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) Conclusion: It is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H to report that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated INPUT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly reach its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And the correct simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input to H is determined by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the UTM, not H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) is a logical consequence of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is logically incorrect to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> argue with a deductive logical
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> premise.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But 1 is only true if H doesn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> go to H.Qn, so H can't correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> go to H.Qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are quite the deceiver making
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sure to always change the subject
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> rather than directly address the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> point at hand.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you seem quite dense. I did NOT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> change the subject, I pointed out
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an error in your statement. You
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> seem to be unable to comprehend that.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) logically follows from (1) is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> true.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But 1 ISN'T True if H <H^> <H^> ->
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H.Qn, as the correctly simulate input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When testing whether or not one
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> assertion logically follows from
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> another the premises are always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "given" to be true even if they are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> false.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Don't know what sort of logic you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> claiming.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And arguemnt with a false premise is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unsound.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We are not yet looking at soundness we
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are looking at validity.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is true that (2) logically follows
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from (1).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We can't move on from this one point
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> until we have mutual agreement.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Very strange then, why are you arguing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about that which was accepted unless
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you disagree to the conditions that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> they were accepted under?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It has long been accepted that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> under the hypothetical condition where
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H can actually determine that the UTM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will run forever, it is correct (and in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fact needed to be correct) for H to go
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H.Qn and say non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> OKAY so then you agree with this?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Premise: When the correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT to embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly reach its final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) Conclusion: It is necessarily
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct for embedded_H to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report that its correctly simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> INPUT cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Under the definition that 'correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input' is as determined by a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM, not H (if it aborts its simulation).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is only stipulated to be correct other
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> details are currently unspecified.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That isn't a 'stipulation', that is a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> DEFINITION.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is obviously your attempt at being a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> weasel.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The DEFINITION of correct simulation is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> results of a UTM simulating the input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Any deviaiton in this means you are just
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> eating your POOP.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It also does not presume that H CAN
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determine that this condition exists, so
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it would be correct, but H might not be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> able to decide to do so. So it may be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct for it to do so, but it might not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually be able to do it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> There is also the case you tend to ignore
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you start with an H that is defined
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to NOT abort, but you try to use (2) to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> claim that it now can abort, the H is (2)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must be the same H that the H^ in (1) was
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> built form
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All of these restrictions are actually in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the actual meaning of the words you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> using, from the context of the problem,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but I state them because knowing you, you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are going to try to break that restrictions.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This seems to be the very first time that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you actually paid close attention, good jo
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> As I asked, how is that different from
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the statement of the requirements on H?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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 its simulated input would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never reach its own final state. In this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> case H aborts the simulation of this input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and transitions to H.qn.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Note, The correct answer is NOT based on a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of N steps, but a simulation by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a UTM which will run until it halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H needs to make ITS decision on the limited
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> N step, so it needs to prove that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer matches.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Remember, when we do this run, H is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> defined, and thus N is a SPECIFIC number,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not an 'arbitrary' number.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You also will need to some how prove that a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern exists in N steps that correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dectect non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This has been previously shown to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> impossible, so you need to actually come up
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> with it or show an actual error in the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proof. You can't just assume it exists.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Great we can move to the next step:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Premise: When embedded_H correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines its simulated INPUT to
>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H cannot possibly reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>> state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> (2) Conclusion: It is necessarily correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>> for embedded_H to report that its correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated INPUT cannot possibly reach its
>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> WARNING, you are getting way into
>>>>>>>>>>>>>>>>>>>>>>>>>>> hypothecctica Unicoprn Terretory, but lets
>>>>>>>>>>>>>>>>>>>>>>>>>>> unpack this statement.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> IF H can correctly deteremine (that means
>>>>>>>>>>>>>>>>>>>>>>>>>>> that there needs to exist a finite algroithm
>>>>>>>>>>>>>>>>>>>>>>>>>>> to determine this case, and that this result
>>>>>>>>>>>>>>>>>>>>>>>>>>> matches the behavior demonstrated by the
>>>>>>>>>>>>>>>>>>>>>>>>>>> definitional UTM simulataion of this input),
>>>>>>>>>>>>>>>>>>>>>>>>>>> that the input will NEVER reach it final state,
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Then yes, it is correct for H to report that
>>>>>>>>>>>>>>>>>>>>>>>>>>> its input can not possible reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>>> state.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Great we have finally begun an honest dialogue.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Note, that if H does this, then the proof
>>>>>>>>>>>>>>>>>>>>>>>>>>> that the input never reached its final state
>>>>>>>>>>>>>>>>>>>>>>>>>>> must have included that fact that the copy of
>>>>>>>>>>>>>>>>>>>>>>>>>>> H inside H^ will also do the exact same thing
>>>>>>>>>>>>>>>>>>>>>>>>>>> with the exact same input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Also, to show the premise is True, you need
>>>>>>>>>>>>>>>>>>>>>>>>>>> to be able to PROVE or actually provide the
>>>>>>>>>>>>>>>>>>>>>>>>>>> exact finite algorithm that it used to
>>>>>>>>>>>>>>>>>>>>>>>>>>> detemine this fact.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>> these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Only if H doesn't abort it simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> On the basis that the pure simulation of N steps
>>>>>>>>>>>>>>>>>>>>>>>> matches an infinitely repeating pattern
>>>>>>>>>>>>>>>>>>>>>>>> embedded_H can correctly determine that this
>>>>>>>>>>>>>>>>>>>>>>>> simulated input cannot possibly reach its final
>>>>>>>>>>>>>>>>>>>>>>>> state whether or not embedded_H aborts its
>>>>>>>>>>>>>>>>>>>>>>>> simulation of this input.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> WHAT N Step pattern shows that H^ <H^> is
>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ these
>>>>>>>>>>>>>>>>>>>>>> steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If that is what happens, then obviously H never
>>>>>>>>>>>>>>>>>>>>> aborted its simulation, so it CAN'T.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> As soon as embedded_H correctly recognizes this
>>>>>>>>>>>>>>>>>>>> infinitely repeating pattern in its correct
>>>>>>>>>>>>>>>>>>>> simulation of N steps of its input it is necessarily
>>>>>>>>>>>>>>>>>>>> correct for it to report that that its simulated
>>>>>>>>>>>>>>>>>>>> input cannot possibly ever reach its halt state.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Only if it proved that it was correct if it does
>>>>>>>>>>>>>>>>>>> abort and go to H.Qn, which it can't.
>>>>>>>>>>>>>>>>>> With logical entailment the conclusion follows from
>>>>>>>>>>>>>>>>>> the premise(s) by logical necessity.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> (1) As soon as embedded_H correctly recognizes this
>>>>>>>>>>>>>>>>>> infinitely repeating pattern in its correct simulation
>>>>>>>>>>>>>>>>>> of N steps of its input
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Which makes the falicay of assuming there is a CORRECT
>>>>>>>>>>>>>>>>> pattern for H to detect in H^, and that H has the
>>>>>>>>>>>>>>>>> ability to detect it.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You are either dishonest or not bright enough to see
>>>>>>>>>>>>>>>> that this is a pattern that would be very easy to match,
>>>>>>>>>>>>>>>> so I guess I am finally done with you.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ these steps
>>>>>>>>>>>>>>>> would
>>>>>>>>>>>>>>>> keep repeating:
>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Which I have proven is NOT a correct pattern if H
>>>>>>>>>>>>>>> actually aborts on it and goes to H.Qn.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yes so it seems that you simply are not bright enough.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, you have proved yourself too dishonest to actually try
>>>>>>>>>>>>> to prove something, but just continue to make your claims
>>>>>>>>>>>>> based on your Fairy Dust powered Unicorns.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> If you can't see how obvious that it is that the above
>>>>>>>>>>>> pattern infinitely repeats you are not very bright.
>>>>>>>>>>>
>>>>>>>>>>> And if you can't see that it is only infinitely looping if H
>>>>>>>>>>> never aborts, then you are dumber than a door nail.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It is a behavior pattern that conclusively proves that the
>>>>>>>>>> pure simulation of the input cannot possibly reach its final
>>>>>>>>>> state.
>>>>>>>>>> Further discussion seems unfruitful.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> No, it only proves that the pure simulation of an H^ built from
>>>>>>>>> an H that will NEVER abort is non-halting.
>>>>>>>>>
>>>>>>>>
>>>>>>>> No. It really does prove that the pure simulation of the input
>>>>>>>> cannot possibly reach the final state of this simulated input.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> How? Your trace is ignoring that there is a conditional inside
>>>>>>> the copy of H that is in H^.
>>>>>>>
>>>>>>> Thus, it doesn't meet the requrements for the 'rule' you are
>>>>>>> trying to quote, which isn't even written for the case of a
>>>>>>> simulator but direct execution, and the replacement of simulation
>>>>>>> with direct exection only applies to UNCONDITIONAL simulation.
>>>>>>>
>>>>>>
>>>>>> You just seem to willfully be stupid to understand that a
>>>>>> simulating halt decider never determines whether or not its input
>>>>>> stops running.
>>>>>>
>>>>>> Instead it determines whether or not the Linz criteria can
>>>>>> possibly be is met:
>>>>>>
>>>>>> computation that halts … the Turing machine will halt whenever it
>>>>>> enters a final state. (Linz:1990:234)
>>>>>>
>>>>>
>>>>> Lying by Double Speak again.
>>>>>
>>>>> By Definition, A Halt Decider decides if its Input represents a
>>>>> Halting Computation, which by definition means does the Computation
>>>>> the input represents Halt. This can be equivalently defined as
>>>>> decides if a UTM simulating its input will Halt or Not.
>>>>>
>>>>> To be correct, its answer must match the behavior of that machine.
>>>>>
>>>>> If you are saying that a "Halt Decider never determines whether or
>>>>> not its input stops runnning", then you are simply not talking
>>>>> about Computation Theory but just your fancy POOP, so nothing you
>>>>> say matters.
>>>>>
>>>>> FAIL.
>>>>>
>>>>
>>>> Since I told you this hundreds of times you are very willfully very
>>>> stupid:
>>>>
>>>> Simulating halt deciders never determine whether or not their input
>>>> stops running. Every input to a simulating halt decider always stops
>>>> running either because it reached its final state or its simulation
>>>> was aborted. Simulating halt deciders determine whether or not the
>>>> Linz criteria can possibly be met: computation that halts … the
>>>> Turing machine will halt whenever it enters a final state.
>>>> (Linz:1990:234)
>>>>
>>>>
>>>
>>> Then you aren't working on the HALTING problem because that is based
>>> on HALITNG of the computation being asked about.
>>
>> Sure I am. As I have told you hundreds of times I am using the Linz
>> definition of halting.
>>
>> computation that halts … the Turing machine will halt whenever it
>> enters a final state. (Linz:1990:234)
>>
>> With the Linz definition of halting it doesn't matter whether or not
>> the simulated input stops running. It only matters whether or not the
>> simulating input could possibly ever reach its final state.
>>
>> The Linz definition of halting is how I link my rebuttal of the
>> halting problem proofs directly to the actual halting problem itself.
>>
>>
>
> You DO understand that when Linz says the Turing Macine will halt
> whenever it enters its final state, he is talking about the Turing
> Machine being run as a totally independent machine,

On 1/26/2022 9:18 PM, Richard Damon wrote:
> On 1/26/22 9:42 PM, olcott wrote:
>> On 1/26/2022 8:29 PM, Richard Damon wrote:
>>> On 1/26/22 9:18 PM, olcott wrote:
>>>> On 1/26/2022 7:25 PM, Richard Damon wrote:
>>>>> On 1/26/22 8:07 PM, olcott wrote:
>>>>>> On 1/26/2022 6:46 PM, Richard Damon wrote:
>>>>>>> On 1/26/22 7:09 PM, olcott wrote:
>>>>>>>> On 1/26/2022 5:54 PM, Richard Damon wrote:
>>>>>>>>> On 1/26/22 9:39 AM, olcott wrote:
>>>>>>>>>> On 1/26/2022 6:03 AM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>> [00000d9a](01)  55              push ebp
>>>>>>>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>>>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>>>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>>>>>>>> [00000da0](01)  c3              ret
>>>>>>>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>>>>>>>
>>>>>>>>>>>> You keep coming back to the idea that only an infinite
>>>>>>>>>>>> simulation of an infinite sequence of configurations can
>>>>>>>>>>>> recognize an infinite sequence of configurations.
>>>>>>>>>>>>
>>>>>>>>>>>> That is ridiculously stupid.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> You can detect SOME (not all) infinite execution in finite
>>>>>>>>>>> time due to patterns.
>>>>>>>>>>>
>>>>>>>>>>> There is no finite pattern in the H^ based on an H that at
>>>>>>>>>>> some point goest to H.Qn that correctly detects the infinite
>>>>>>>>>>> behavior.
>>>>>>>>>>>
>>>>>>>>>>> THAT is the point you miss, SOME infinite patterns are only
>>>>>>>>>>> really infinite when you work them out to infinitity.
>>>>>>>>>>>
>>>>>>>>>>> Part of your problem is that the traces you look at are
>>>>>>>>>>> wrong. When H simulates H^, it needs to trace out the actual
>>>>>>>>>>> execution path of the H that part of H^, not switch to
>>>>>>>>>>> tracing what it was tracing.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You simply lack the intellectual capacity to understand that
>>>>>>>>>> when embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ this is the pattern:
>>>>>>>>>>
>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Which only happens if H NEVER aborts its simulation and thus
>>>>>>>>> can't give an answer.
>>>>>>>>>
>>>>>>>>> If H DOES abort its simulation at ANY point, then the above is
>>>>>>>>> NOT the accurate trace of the behavior of the input.
>>>>>>>>>
>>>>>>>>>
>>>>>>>> YOU ARE MUCH DUMBER THAN A BOX OF ROCKS BECAUSE
>>>>>>>>
>>>>>>>> _Infinite_Loop()
>>>>>>>> [00000d9a](01)  55              push ebp
>>>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>>>> [00000da0](01)  c3              ret
>>>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>>>
>>>>>>>> You exactly same jackass point equally applies to this case:
>>>>>>>>
>>>>>>>> Unless H simulates the infinite loop infinitely it is not an
>>>>>>>> accurate simulation.
>>>>>>>>
>>>>>>>
>>>>>>> So, no rubbutal just red herring sushi.
>>>>>>>
>>>>>>>
>>>>>>> The key point you miss is that if H does abort its simulation,
>>>>>>> then it needs to take into account that the machine it is
>>>>>>> simulating will do so too.
>>>>>>>
>>>>>>
>>>>>> As long as H correctly determines that its simulated input cannot
>>>>>> possibly reach its final state in any finite number of steps it
>>>>>> has conclusively proved that this input never halts according to
>>>>>> the Linz definition:
>>>>>
>>>>>
>>>>> But it needs to prove that the UTM of its input never halts, and
>>>>> for H^, that means even if the H insisde H^ goes to H.Qn which
>>>>> means that H^ goes to H^.Qn, which of course Halts.
>>>>>
>>>>
>>>> As soon as embedded_H (not H) determines that its simulated input
>>>> ⟨Ĥ⟩ applied to ⟨Ĥ⟩ cannot possibly reach its final state in any
>>>> finite number of steps it terminates this simulation immediately
>>>> stopping every element of the entire chain of nested simulations.
>>>>
>>>
>>> If you are claiming that embedded_H and H behave differently then you
>>> have been lying that you built H^ by the instruction of Linz, as the
>>> copy of H inside H^ is IDENTICAL (except what happens AFTER getting
>>> to H.Qy)
>>>
>>> Now, IF H could make that proof, then it would be correct to go to
>>> H.Qn, but it would need to take into account that H^ halts if its
>>> copy of H goes to H.Qn, so this is NEVER possible.
>>>
>>> FAIL
>>>
>>>> Then embedded_H transitions to Ĥ.qn which causes the original Ĥ
>>>> applied to ⟨Ĥ⟩ to halt. Since Ĥ applied to ⟨Ĥ⟩ is not an input to
>>>> embedded_H and a decider is only accountable for computing the
>>>> mapping from its actual inputs to an accept or reject state it makes
>>>> no difference that Ĥ applied to ⟨Ĥ⟩ halts.
>>>
>>> Thus you have admitted to LYING about working on the Halting problem
>>> as if you were the embedded_H would be the same algorithm as H, and
>>> the requirement on H was that is IS accoutable for the machine its
>>> input represents,
>>
>> You are simply too freaking stupid to understand that deciders thus
>> halt deciders are only accountable for computing the mapping from
>> their actual inputs (nothing else in the whole freaking universe
>> besides their actual inputs) to an accept or reject state.
>>
>> An actual computer scientist would know this.
>>
>
> It seems you don't understand the difference between capabilities and
> requirements.
>
> H is only CAPABLE of deciding based on what it can do. It can only
> computate a mapping based on what it actually can do.
>
> It is REQUIRED to meet its requirements, which is to decide on the
> behavior of what its input would do if given to a UTM.
>

On 1/26/2022 10:07 PM, Richard Damon wrote:
> On 1/26/22 10:59 PM, olcott wrote:
>> On 1/26/2022 9:18 PM, Richard Damon wrote:
>>> On 1/26/22 9:42 PM, olcott wrote:
>>>> On 1/26/2022 8:29 PM, Richard Damon wrote:
>>>>> On 1/26/22 9:18 PM, olcott wrote:
>>>>>> On 1/26/2022 7:25 PM, Richard Damon wrote:
>>>>>>> On 1/26/22 8:07 PM, olcott wrote:
>>>>>>>> On 1/26/2022 6:46 PM, Richard Damon wrote:
>>>>>>>>> On 1/26/22 7:09 PM, olcott wrote:
>>>>>>>>>> On 1/26/2022 5:54 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/26/22 9:39 AM, olcott wrote:
>>>>>>>>>>>> On 1/26/2022 6:03 AM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>> [00000d9a](01)  55              push ebp
>>>>>>>>>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>>>>>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>>>>>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>>>>>>>>>> [00000da0](01)  c3              ret
>>>>>>>>>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You keep coming back to the idea that only an infinite
>>>>>>>>>>>>>> simulation of an infinite sequence of configurations can
>>>>>>>>>>>>>> recognize an infinite sequence of configurations.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That is ridiculously stupid.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> You can detect SOME (not all) infinite execution in finite
>>>>>>>>>>>>> time due to patterns.
>>>>>>>>>>>>>
>>>>>>>>>>>>> There is no finite pattern in the H^ based on an H that at
>>>>>>>>>>>>> some point goest to H.Qn that correctly detects the
>>>>>>>>>>>>> infinite behavior.
>>>>>>>>>>>>>
>>>>>>>>>>>>> THAT is the point you miss, SOME infinite patterns are only
>>>>>>>>>>>>> really infinite when you work them out to infinitity.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Part of your problem is that the traces you look at are
>>>>>>>>>>>>> wrong. When H simulates H^, it needs to trace out the
>>>>>>>>>>>>> actual execution path of the H that part of H^, not switch
>>>>>>>>>>>>> to tracing what it was tracing.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You simply lack the intellectual capacity to understand that
>>>>>>>>>>>> when embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ this is the
>>>>>>>>>>>> pattern:
>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Which only happens if H NEVER aborts its simulation and thus
>>>>>>>>>>> can't give an answer.
>>>>>>>>>>>
>>>>>>>>>>> If H DOES abort its simulation at ANY point, then the above
>>>>>>>>>>> is NOT the accurate trace of the behavior of the input.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>> YOU ARE MUCH DUMBER THAN A BOX OF ROCKS BECAUSE
>>>>>>>>>>
>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>> [00000d9a](01)  55              push ebp
>>>>>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>>>>>> [00000da0](01)  c3              ret
>>>>>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>>>>>
>>>>>>>>>> You exactly same jackass point equally applies to this case:
>>>>>>>>>>
>>>>>>>>>> Unless H simulates the infinite loop infinitely it is not an
>>>>>>>>>> accurate simulation.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> So, no rubbutal just red herring sushi.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> The key point you miss is that if H does abort its simulation,
>>>>>>>>> then it needs to take into account that the machine it is
>>>>>>>>> simulating will do so too.
>>>>>>>>>
>>>>>>>>
>>>>>>>> As long as H correctly determines that its simulated input
>>>>>>>> cannot possibly reach its final state in any finite number of
>>>>>>>> steps it has conclusively proved that this input never halts
>>>>>>>> according to the Linz definition:
>>>>>>>
>>>>>>>
>>>>>>> But it needs to prove that the UTM of its input never halts, and
>>>>>>> for H^, that means even if the H insisde H^ goes to H.Qn which
>>>>>>> means that H^ goes to H^.Qn, which of course Halts.
>>>>>>>
>>>>>>
>>>>>> As soon as embedded_H (not H) determines that its simulated input
>>>>>> ⟨Ĥ⟩ applied to ⟨Ĥ⟩ cannot possibly reach its final state in any
>>>>>> finite number of steps it terminates this simulation immediately
>>>>>> stopping every element of the entire chain of nested simulations.
>>>>>>
>>>>>
>>>>> If you are claiming that embedded_H and H behave differently then
>>>>> you have been lying that you built H^ by the instruction of Linz,
>>>>> as the copy of H inside H^ is IDENTICAL (except what happens AFTER
>>>>> getting to H.Qy)
>>>>>
>>>>> Now, IF H could make that proof, then it would be correct to go to
>>>>> H.Qn, but it would need to take into account that H^ halts if its
>>>>> copy of H goes to H.Qn, so this is NEVER possible.
>>>>>
>>>>> FAIL
>>>>>
>>>>>> Then embedded_H transitions to Ĥ.qn which causes the original Ĥ
>>>>>> applied to ⟨Ĥ⟩ to halt. Since Ĥ applied to ⟨Ĥ⟩ is not an input to
>>>>>> embedded_H and a decider is only accountable for computing the
>>>>>> mapping from its actual inputs to an accept or reject state it
>>>>>> makes no difference that Ĥ applied to ⟨Ĥ⟩ halts.
>>>>>
>>>>> Thus you have admitted to LYING about working on the Halting
>>>>> problem as if you were the embedded_H would be the same algorithm
>>>>> as H, and the requirement on H was that is IS accoutable for the
>>>>> machine its input represents,
>>>>
>>>> You are simply too freaking stupid to understand that deciders thus
>>>> halt deciders are only accountable for computing the mapping from
>>>> their actual inputs (nothing else in the whole freaking universe
>>>> besides their actual inputs) to an accept or reject state.
>>>>
>>>> An actual computer scientist would know this.
>>>>
>>>
>>> It seems you don't understand the difference between capabilities and
>>> requirements.
>>>
>>> H is only CAPABLE of deciding based on what it can do. It can only
>>> computate a mapping based on what it actually can do.
>>>
>>> It is REQUIRED to meet its requirements, which is to decide on the
>>> behavior of what its input would do if given to a UTM.
>>>
>>
>> embedded_H must only determine whether or not is simulated input can
>> ever reach its final state in any finite number of steps.
>>
>
> Again, you seem to be lying about working on the Halting Problem and
> Linz proof.
>
> If you were working on the Halting Problem and Linz proof then
> embedded_H would be identical to H, as required by Linz, and the correct
> answer for the 'behavior' of the input to embedded_H <H^> <H^> would be
> the behavior of UTM(<H^>,<H^>) which if embedded_H goes to H.Qn then we
> know that H^ will go to H^.Qn and Halt, and thus H/embedded_H going to
> H.Qn is incorrect.
>
> So, you are just admitting that you are lying or are too stupid to
> understan what you are talking about.
>
> Which is it?
>

On 1/26/2022 8:37 PM, olcott wrote:

> nothing (again) <

Shut up idiot.

On 1/27/2022 5:56 AM, Richard Damon wrote:
> On 1/26/22 11:37 PM, olcott wrote:
>> On 1/26/2022 10:07 PM, Richard Damon wrote:
>>> On 1/26/22 10:59 PM, olcott wrote:
>>>> On 1/26/2022 9:18 PM, Richard Damon wrote:
>>>>> On 1/26/22 9:42 PM, olcott wrote:
>>>>>> On 1/26/2022 8:29 PM, Richard Damon wrote:
>>>>>>> On 1/26/22 9:18 PM, olcott wrote:
>>>>>>>> On 1/26/2022 7:25 PM, Richard Damon wrote:
>>>>>>>>> On 1/26/22 8:07 PM, olcott wrote:
>>>>>>>>>> On 1/26/2022 6:46 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/26/22 7:09 PM, olcott wrote:
>>>>>>>>>>>> On 1/26/2022 5:54 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/26/22 9:39 AM, olcott wrote:
>>>>>>>>>>>>>> On 1/26/2022 6:03 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>> [00000d9a](01)  55              push ebp
>>>>>>>>>>>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>>>>>>>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>>>>>>>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>>>>>>>>>>>> [00000da0](01)  c3              ret
>>>>>>>>>>>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You keep coming back to the idea that only an infinite
>>>>>>>>>>>>>>>> simulation of an infinite sequence of configurations can
>>>>>>>>>>>>>>>> recognize an infinite sequence of configurations.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> That is ridiculously stupid.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You can detect SOME (not all) infinite execution in
>>>>>>>>>>>>>>> finite time due to patterns.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> There is no finite pattern in the H^ based on an H that
>>>>>>>>>>>>>>> at some point goest to H.Qn that correctly detects the
>>>>>>>>>>>>>>> infinite behavior.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> THAT is the point you miss, SOME infinite patterns are
>>>>>>>>>>>>>>> only really infinite when you work them out to infinitity.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Part of your problem is that the traces you look at are
>>>>>>>>>>>>>>> wrong. When H simulates H^, it needs to trace out the
>>>>>>>>>>>>>>> actual execution path of the H that part of H^, not
>>>>>>>>>>>>>>> switch to tracing what it was tracing.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You simply lack the intellectual capacity to understand
>>>>>>>>>>>>>> that when embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ this is
>>>>>>>>>>>>>> the pattern:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Which only happens if H NEVER aborts its simulation and
>>>>>>>>>>>>> thus can't give an answer.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If H DOES abort its simulation at ANY point, then the above
>>>>>>>>>>>>> is NOT the accurate trace of the behavior of the input.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>> YOU ARE MUCH DUMBER THAN A BOX OF ROCKS BECAUSE
>>>>>>>>>>>>
>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>> [00000d9a](01)  55              push ebp
>>>>>>>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>>>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>>>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>>>>>>>> [00000da0](01)  c3              ret
>>>>>>>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>>>>>>>
>>>>>>>>>>>> You exactly same jackass point equally applies to this case:
>>>>>>>>>>>>
>>>>>>>>>>>> Unless H simulates the infinite loop infinitely it is not an
>>>>>>>>>>>> accurate simulation.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> So, no rubbutal just red herring sushi.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The key point you miss is that if H does abort its
>>>>>>>>>>> simulation, then it needs to take into account that the
>>>>>>>>>>> machine it is simulating will do so too.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> As long as H correctly determines that its simulated input
>>>>>>>>>> cannot possibly reach its final state in any finite number of
>>>>>>>>>> steps it has conclusively proved that this input never halts
>>>>>>>>>> according to the Linz definition:
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> But it needs to prove that the UTM of its input never halts,
>>>>>>>>> and for H^, that means even if the H insisde H^ goes to H.Qn
>>>>>>>>> which means that H^ goes to H^.Qn, which of course Halts.
>>>>>>>>>
>>>>>>>>
>>>>>>>> As soon as embedded_H (not H) determines that its simulated
>>>>>>>> input ⟨Ĥ⟩ applied to ⟨Ĥ⟩ cannot possibly reach its final state
>>>>>>>> in any finite number of steps it terminates this simulation
>>>>>>>> immediately stopping every element of the entire chain of nested
>>>>>>>> simulations.
>>>>>>>>
>>>>>>>
>>>>>>> If you are claiming that embedded_H and H behave differently then
>>>>>>> you have been lying that you built H^ by the instruction of Linz,
>>>>>>> as the copy of H inside H^ is IDENTICAL (except what happens
>>>>>>> AFTER getting to H.Qy)
>>>>>>>
>>>>>>> Now, IF H could make that proof, then it would be correct to go
>>>>>>> to H.Qn, but it would need to take into account that H^ halts if
>>>>>>> its copy of H goes to H.Qn, so this is NEVER possible.
>>>>>>>
>>>>>>> FAIL
>>>>>>>
>>>>>>>> Then embedded_H transitions to Ĥ.qn which causes the original Ĥ
>>>>>>>> applied to ⟨Ĥ⟩ to halt. Since Ĥ applied to ⟨Ĥ⟩ is not an input
>>>>>>>> to embedded_H and a decider is only accountable for computing
>>>>>>>> the mapping from its actual inputs to an accept or reject state
>>>>>>>> it makes no difference that Ĥ applied to ⟨Ĥ⟩ halts.
>>>>>>>
>>>>>>> Thus you have admitted to LYING about working on the Halting
>>>>>>> problem as if you were the embedded_H would be the same algorithm
>>>>>>> as H, and the requirement on H was that is IS accoutable for the
>>>>>>> machine its input represents,
>>>>>>
>>>>>> You are simply too freaking stupid to understand that deciders
>>>>>> thus halt deciders are only accountable for computing the mapping
>>>>>> from their actual inputs (nothing else in the whole freaking
>>>>>> universe besides their actual inputs) to an accept or reject state.
>>>>>>
>>>>>> An actual computer scientist would know this.
>>>>>>
>>>>>
>>>>> It seems you don't understand the difference between capabilities
>>>>> and requirements.
>>>>>
>>>>> H is only CAPABLE of deciding based on what it can do. It can only
>>>>> computate a mapping based on what it actually can do.
>>>>>
>>>>> It is REQUIRED to meet its requirements, which is to decide on the
>>>>> behavior of what its input would do if given to a UTM.
>>>>>
>>>>
>>>> embedded_H must only determine whether or not is simulated input can
>>>> ever reach its final state in any finite number of steps.
>>>>
>>>
>>> Again, you seem to be lying about working on the Halting Problem and
>>> Linz proof.
>>>
>>> If you were working on the Halting Problem and Linz proof then
>>> embedded_H would be identical to H, as required by Linz, and the
>>> correct answer for the 'behavior' of the input to embedded_H <H^>
>>> <H^> would be the behavior of UTM(<H^>,<H^>) which if embedded_H goes
>>> to H.Qn then we know that H^ will go to H^.Qn and Halt, and thus
>>> H/embedded_H going to H.Qn is incorrect.
>>>
>>> So, you are just admitting that you are lying or are too stupid to
>>> understan what you are talking about.
>>>
>>> Which is it?
>>>
>>
>> I will not tolerate any digression from the point at hand until we
>> have mutual agreement. This is verified as completely true entirely on
>> the basis of the meaning of its words:
>>
>> embedded_H must only determine whether or not its simulated input can
>> ever reach its final state in any finite number of steps.
>>
>>
>
> Translation: You will ignroe any disagreement with your incorrect
> statement because you need to get people to accept your falso premise
> for your unsound argument to work.
>
> The problem with your statement is that you are showing that you atually
> mean something different than the true meaning of the words.
>
> H (and thus embedded_H) need to determine whether or not its simuleted
> input will ever reach its final state for EVERY POSSIBLE finite number
> of steps, i.e. as determine by a UTM.
>

On 1/27/2022 9:25 AM, olcott wrote:
> On 1/27/2022 5:56 AM, Richard Damon wrote:
>> On 1/26/22 11:37 PM, olcott wrote:
>>> On 1/26/2022 10:07 PM, Richard Damon wrote:
>>>> On 1/26/22 10:59 PM, olcott wrote:
>>>>> On 1/26/2022 9:18 PM, Richard Damon wrote:
>>>>>> On 1/26/22 9:42 PM, olcott wrote:
>>>>>>> On 1/26/2022 8:29 PM, Richard Damon wrote:
>>>>>>>> On 1/26/22 9:18 PM, olcott wrote:
>>>>>>>>> On 1/26/2022 7:25 PM, Richard Damon wrote:
>>>>>>>>>> On 1/26/22 8:07 PM, olcott wrote:
>>>>>>>>>>> On 1/26/2022 6:46 PM, Richard Damon wrote:
>>>>>>>>>>>> On 1/26/22 7:09 PM, olcott wrote:
>>>>>>>>>>>>> On 1/26/2022 5:54 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 1/26/22 9:39 AM, olcott wrote:
>>>>>>>>>>>>>>> On 1/26/2022 6:03 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>> [00000d9a](01)  55              push ebp
>>>>>>>>>>>>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>>>>>>>>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>>>>>>>>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>>>>>>>>>>>>> [00000da0](01)  c3              ret
>>>>>>>>>>>>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You keep coming back to the idea that only an infinite
>>>>>>>>>>>>>>>>> simulation of an infinite sequence of configurations
>>>>>>>>>>>>>>>>> can recognize an infinite sequence of configurations.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> That is ridiculously stupid.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You can detect SOME (not all) infinite execution in
>>>>>>>>>>>>>>>> finite time due to patterns.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> There is no finite pattern in the H^ based on an H that
>>>>>>>>>>>>>>>> at some point goest to H.Qn that correctly detects the
>>>>>>>>>>>>>>>> infinite behavior.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> THAT is the point you miss, SOME infinite patterns are
>>>>>>>>>>>>>>>> only really infinite when you work them out to infinitity.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Part of your problem is that the traces you look at are
>>>>>>>>>>>>>>>> wrong. When H simulates H^, it needs to trace out the
>>>>>>>>>>>>>>>> actual execution path of the H that part of H^, not
>>>>>>>>>>>>>>>> switch to tracing what it was tracing.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You simply lack the intellectual capacity to understand
>>>>>>>>>>>>>>> that when embedded_H simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩ this is
>>>>>>>>>>>>>>> the pattern:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Which only happens if H NEVER aborts its simulation and
>>>>>>>>>>>>>> thus can't give an answer.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If H DOES abort its simulation at ANY point, then the
>>>>>>>>>>>>>> above is NOT the accurate trace of the behavior of the input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>> YOU ARE MUCH DUMBER THAN A BOX OF ROCKS BECAUSE
>>>>>>>>>>>>>
>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>> [00000d9a](01)  55              push ebp
>>>>>>>>>>>>> [00000d9b](02)  8bec            mov ebp,esp
>>>>>>>>>>>>> [00000d9d](02)  ebfe            jmp 00000d9d
>>>>>>>>>>>>> [00000d9f](01)  5d              pop ebp
>>>>>>>>>>>>> [00000da0](01)  c3              ret
>>>>>>>>>>>>> Size in bytes:(0007) [00000da0]
>>>>>>>>>>>>>
>>>>>>>>>>>>> You exactly same jackass point equally applies to this case:
>>>>>>>>>>>>>
>>>>>>>>>>>>> Unless H simulates the infinite loop infinitely it is not
>>>>>>>>>>>>> an accurate simulation.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> So, no rubbutal just red herring sushi.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The key point you miss is that if H does abort its
>>>>>>>>>>>> simulation, then it needs to take into account that the
>>>>>>>>>>>> machine it is simulating will do so too.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> As long as H correctly determines that its simulated input
>>>>>>>>>>> cannot possibly reach its final state in any finite number of
>>>>>>>>>>> steps it has conclusively proved that this input never halts
>>>>>>>>>>> according to the Linz definition:
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> But it needs to prove that the UTM of its input never halts,
>>>>>>>>>> and for H^, that means even if the H insisde H^ goes to H.Qn
>>>>>>>>>> which means that H^ goes to H^.Qn, which of course Halts.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> As soon as embedded_H (not H) determines that its simulated
>>>>>>>>> input ⟨Ĥ⟩ applied to ⟨Ĥ⟩ cannot possibly reach its final state
>>>>>>>>> in any finite number of steps it terminates this simulation
>>>>>>>>> immediately stopping every element of the entire chain of
>>>>>>>>> nested simulations.
>>>>>>>>>
>>>>>>>>
>>>>>>>> If you are claiming that embedded_H and H behave differently
>>>>>>>> then you have been lying that you built H^ by the instruction of
>>>>>>>> Linz, as the copy of H inside H^ is IDENTICAL (except what
>>>>>>>> happens AFTER getting to H.Qy)
>>>>>>>>
>>>>>>>> Now, IF H could make that proof, then it would be correct to go
>>>>>>>> to H.Qn, but it would need to take into account that H^ halts if
>>>>>>>> its copy of H goes to H.Qn, so this is NEVER possible.
>>>>>>>>
>>>>>>>> FAIL
>>>>>>>>
>>>>>>>>> Then embedded_H transitions to Ĥ.qn which causes the original Ĥ
>>>>>>>>> applied to ⟨Ĥ⟩ to halt. Since Ĥ applied to ⟨Ĥ⟩ is not an input
>>>>>>>>> to embedded_H and a decider is only accountable for computing
>>>>>>>>> the mapping from its actual inputs to an accept or reject state
>>>>>>>>> it makes no difference that Ĥ applied to ⟨Ĥ⟩ halts.
>>>>>>>>
>>>>>>>> Thus you have admitted to LYING about working on the Halting
>>>>>>>> problem as if you were the embedded_H would be the same
>>>>>>>> algorithm as H, and the requirement on H was that is IS
>>>>>>>> accoutable for the machine its input represents,
>>>>>>>
>>>>>>> You are simply too freaking stupid to understand that deciders
>>>>>>> thus halt deciders are only accountable for computing the mapping
>>>>>>> from their actual inputs (nothing else in the whole freaking
>>>>>>> universe besides their actual inputs) to an accept or reject state.
>>>>>>>
>>>>>>> An actual computer scientist would know this.
>>>>>>>
>>>>>>
>>>>>> It seems you don't understand the difference between capabilities
>>>>>> and requirements.
>>>>>>
>>>>>> H is only CAPABLE of deciding based on what it can do. It can only
>>>>>> computate a mapping based on what it actually can do.
>>>>>>
>>>>>> It is REQUIRED to meet its requirements, which is to decide on the
>>>>>> behavior of what its input would do if given to a UTM.
>>>>>>
>>>>>
>>>>> embedded_H must only determine whether or not is simulated input
>>>>> can ever reach its final state in any finite number of steps.
>>>>>
>>>>
>>>> Again, you seem to be lying about working on the Halting Problem and
>>>> Linz proof.
>>>>
>>>> If you were working on the Halting Problem and Linz proof then
>>>> embedded_H would be identical to H, as required by Linz, and the
>>>> correct answer for the 'behavior' of the input to embedded_H <H^>
>>>> <H^> would be the behavior of UTM(<H^>,<H^>) which if embedded_H
>>>> goes to H.Qn then we know that H^ will go to H^.Qn and Halt, and
>>>> thus H/embedded_H going to H.Qn is incorrect.
>>>>
>>>> So, you are just admitting that you are lying or are too stupid to
>>>> understan what you are talking about.
>>>>
>>>> Which is it?
>>>>
>>>
>>> I will not tolerate any digression from the point at hand until we
>>> have mutual agreement. This is verified as completely true entirely
>>> on the basis of the meaning of its words:
>>>
>>> embedded_H must only determine whether or not its simulated input can
>>> ever reach its final state in any finite number of steps.
>>>
>>>
>>
>> Translation: You will ignroe any disagreement with your incorrect
>> statement because you need to get people to accept your falso premise
>> for your unsound argument to work.
>>
>> The problem with your statement is that you are showing that you
>> atually mean something different than the true meaning of the words.
>>
>> H (and thus embedded_H) need to determine whether or not its simuleted
>> input will ever reach its final state for EVERY POSSIBLE finite number
>> of steps, i.e. as determine by a UTM.
>>
>
> ∃N such that the pure simulation of the input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
> reaches ⟨Ĥ⟩.qy or ⟨Ĥ⟩.qn in N steps.

On 1/29/2022 11:34 AM, Ben Bacarisse wrote:
> Richard Damon <Richard@Damon-Family.org> writes:
>
>> And the 'actual behavior of its actual inputs' is DEFINED to be what
>> the computation the input actually does when run as an independent
>> machine, or what a UTM will do when simulating that input.
>>
>> If that isn't the meaning you are using, then you are just lying that
>> you are working on the halting problem, which is what seems to be the
>> case. (That you are lying that is).
>
> It is certainly true that PO is not addressing the halting problem. He
> has been 100% clear that false is, in his "opinion", the correct result
> for at least one halting computation. This is not in dispute (unless
> he's retracted that and I missed it).
>

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

There are no finite number of steps of the pure simulation of ⟨Ĥ⟩
applied to ⟨Ĥ⟩ by embedded_H such that this simulated input meets the
Linz definition of halting:

computation that halts … the Turing machine will halt whenever it enters
a final state. (Linz:1990:234)

Therefore it is correct to say that the input to embedded_H specifies a
sequence of configurations that never halts.

https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3

> To you and I, this means that he's not working on the halting problem,
> but I am not sure you can say he is lying about that. For one thing,
> how can he be intending to deceive (a core part of lying) when he's been
> clear the he accepts the wrong answer as being the right one? If
> someone claims to be working on "the addition problem", and also claims
> that 2+2=5 is correct, it's hard to consider either claim to be a lie.
> The person is just deeply confused.
>
> But what sort of confused can explain this nonsense? I think the answer
> lies in PO's background. The "binary square root" function is not
> computable as far as a mathematician is concerned because no TM can halt
> with, say, sqrt(0b10) on the tape. But to an engineer, the function
> poses no problem because we can get as close as we like. If
> 0b1.01101010000 is not good enough, just add more digits.
>
> The point is I think PO does not know what a formal, mathematical
> problem really is. To him, anything about code, machines or programs is
> about solving an engineering problem "well enough" -- with "well enough"
> open to be defined by PO himself.
>
> More disturbing to me is that he is not even talking about Turing
> machines, again as evidenced by his own plain words. It is not in
> dispute that he claims that two (deterministic) TMs, one an identical
> copy of the other, can transition to different states despite both being
> presented with identical input. These are not Turing machines but Magic
> machines, and I can't see how any discussion can be had while the action
> of the things being considered is not a simple function of the input and
> the state transition graph.
>

H and embedded_H are not identical, one has an infinite loop appended to
its accept state.

I will not tolerate digression into this side issue until after mutual
agreement is achieved on the first point. Until then these side issues
are no more than a dishonest dodge distraction away from the main point.

> This is why I stopped replying. While there are things to say about
> PO's Other Halting problem (principally that even the POOH problem can't
> be solved), I had nothing more to say while the "machines" being
> discussed are magic.
>

--
Copyright 2021 Pete Olcott "Talent hits a target no one else can hit;
Genius hits a target no one else can see." Arthur Schopenhauer

On 1/29/2022 10:09 AM, olcott wrote:

(nothing)

Get a brain you impotent blithering twatwaffle,

On 1/29/2022 12:45 PM, Greta Baine wrote:
> On 1/29/2022 10:09 AM, olcott wrote:
>
> (nothing)
>
> Get a brain you impotent blithering twatwaffle,

This is merely another way of saying the you know that you are totally
incompetent to point out even a single error in anything that I have said.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 1/29/2022 11:09 AM, olcott wrote:
> On 1/29/2022 12:45 PM, Greta Baine wrote:
>> On 1/29/2022 10:09 AM, olcott wrote:
>>
>> (nothing)
>>
>> Get a brain you impotent blithering twatwaffle,
>
> This is merely another way of saying the you know that you are totally
> incompetent to point out even a single error in anything that I have said.
>

Your posts are entirely free of meaningful content; they resemble an
explosion at an ASCII factory - random characters thrown onto a screen.
No comment on your posts is necessary except for this advice:
Shut up idiot.

On 1/30/2022 7:44 AM, Richard Damon wrote:
> On 1/30/22 8:13 AM, olcott wrote:
>> On 1/29/2022 11:34 AM, Ben Bacarisse wrote:
>>> Richard Damon <Richard@Damon-Family.org> writes:
>>>
>>>> And the 'actual behavior of its actual inputs' is DEFINED to be what
>>>> the computation the input actually does when run as an independent
>>>> machine, or what a UTM will do when simulating that input.
>>>>
>>>> If that isn't the meaning you are using, then you are just lying that
>>>> you are working on the halting problem, which is what seems to be the
>>>> case. (That you are lying that is).
>>>
>>> It is certainly true that PO is not addressing the halting problem.  He
>>> has been 100% clear that false is, in his "opinion", the correct result
>>> for at least one halting computation.  This is not in dispute (unless
>>> he's retracted that and I missed it).
>>>
>>> To you and I, this means that he's not working on the halting problem,
>>> but I am not sure you can say he is lying about that.  For one thing,
>>> how can he be intending to deceive (a core part of lying) when he's been
>>> clear the he accepts the wrong answer as being the right one?  If
>>> someone claims to be working on "the addition problem", and also claims
>>> that 2+2=5 is correct, it's hard to consider either claim to be a lie.
>>> The person is just deeply confused.
>>>
>>> But what sort of confused can explain this nonsense?  I think the answer
>>> lies in PO's background.  The "binary square root" function is not
>>> computable as far as a mathematician is concerned because no TM can halt
>>> with, say, sqrt(0b10) on the tape.  But to an engineer, the function
>>> poses no problem because we can get as close as we like.  If
>>> 0b1.01101010000 is not good enough, just add more digits.
>>>
>>> The point is I think PO does not know what a formal, mathematical
>>> problem really is.  To him, anything about code, machines or programs is
>>> about solving an engineering problem "well enough" -- with "well enough"
>>> open to be defined by PO himself.
>>>
>>> More disturbing to me is that he is not even talking about Turing
>>> machines, again as evidenced by his own plain words.  It is not in
>>> dispute that he claims that two (deterministic) TMs, one an identical
>>> copy of the other, can transition to different states despite both being
>>> presented with identical input.  These are not Turing machines but Magic
>>> machines, and I can't see how any discussion can be had while the action
>>> of the things being considered is not a simple function of the input and
>>> the state transition graph.
>>>
>>
>> Although Turing machines might not be able to tell that two
>> computations differ on their basis of their machine address x86
>> machines can do this.
>
> But the proof is on Turing Machines, and not all x86 'programs' are the
> equivalent to Turing Machines, only those that meet the requirements of
> being a Computation.
>
> This seems to be the core of your problem, you don't understand what a
> computation actually is, and want to use the WRONG definition of it
> being anything a modern computer does. Wrong defintions, wrong results.
>

When a halt decider bases its halt status decision on the behavior of
the correct simulation of a finite number of N steps of its input there
is nothing about this that is not a computation.

When this simulating halt decider correctly determines that its
simulated input cannot possibly reach its final state in any finite
number of steps this too is computable.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

When the copy of H embedded at Ĥ.qx correctly recognizes this repeating
pattern:

When Ĥ is applied to ⟨Ĥ⟩
Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩

Then these steps would keep repeating:
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...

This too is a computation.

When embedded_H correctly recognizes the above repeating pattern then
this gives embedded_H the basis to know that its simulated input will
never reach its final state thus fails to meet this Linz definition of
halting: computation that halts … the Turing machine will halt whenever
it enters a final state. (Linz:1990:234).

The source of the errors of everyone else on this is failing to realize
that:

Because all simulating halt deciders are deciders they are only
accountable for computing the mapping from their input finite strings to
an accept or reject state on the basis of whether or not their correctly
simulated input can possibly reach its final state in any finite number
of steps.

https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer