On 8/25/21 10:15 AM, olcott wrote:
> On 8/25/2021 7:19 AM, Richard Damon wrote:
>> On 8/24/21 11:53 PM, olcott wrote:
>>> On 8/24/2021 7:35 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 8/24/2021 9:09 AM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 8/23/2021 10:09 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 8/23/2021 6:26 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 8/23/2021 2:30 PM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> I ignore dishonest dodges away from the point at hand.
>>>>>>>>>> OK, let's do that:
>>>>>>>>>>        "⟨Ĥ⟩ ⟨Ĥ⟩ is not a string that encodes a halting
>>>>>>>>>> computation"
>>>>>>>>>> is wrong.  You wrote that immediately after a line showing that Ĥ
>>>>>>>>>> applied to ⟨Ĥ⟩ halts.  Everything since then has just been
>>>>>>>>>> dodging this
>>>>>>>>>> error.
>>>>>>>>>>
>>>>>>>>>>> When we define Ĵ to be exactly like Ĥ except that it has a UTM
>>>>>>>>>>> at Ĵ.qx
>>>>>>>>>>> instead of a simulating halt decider then we can see that Ĵ
>>>>>>>>>>> applied to
>>>>>>>>>>> ⟨Ĵ⟩ never halts.
>>>>>>>>>> The details are mess, but basically, yes.  Detail errors (that
>>>>>>>>>> would get
>>>>>>>>>> your paper rejected out of hand) available if you ask really
>>>>>>>>>> nicely.
>>>>>>>>>
>>>>>>>>> Which details do you think are incorrect?
>>>>>>>>
>>>>>>>> A UTM is not a decider so the hat construction can't be applied to
>>>>>>>> it.
>>>>>>>> And if we make a "UTM-decider" (a TM that is a pure simulator
>>>>>>>> except
>>>>>>>> that is accepts those computations whose simulations terminate) we
>>>>>>>> still
>>>>>>>> can't apply the hat construction because it won't have a rejecting
>>>>>>>> state.  Thus your use of "exactly like Ĥ except..." is, at best,
>>>>>>>> disingenuous.  The differences must be greater than the "except..."
>>>>>>>> clause suggests.
>>>>>>>
>>>>>>> My whole purpose was to simply show what happens when the simulating
>>>>>>> halt decide at Ĥ.qx only simulates its input.
>>>>>> I know, but you wanted to know what details you'd got wrong.
>>>>>>
>>>>>
>>>>> If my plan was to swap the simulating halt decider at Ĥ.qx with a UTM
>>>>> and then rename this machine to Ĵ and I did swap swap the simulating
>>>>> halt decider at Ĥ.qx with a UTM and rename this machine to Ĵ then it
>>>>> is a God damned lie that I got anything wrong.
>>>>
>>>> No.  You won't get it unless you really try.
>>>>
>>>>>>> We can still have the same final states, except now that are
>>>>>>> unreachable dead code.
>>>>>> Except you show below this unreachable state being reached:
>>>>>
>>>>> No I do frigging not.
>>>>
>>>> Yes you did.  I quoted you: Ĵ.q0 ⟨Ĵ⟩ ⊢* Ĵ.qx ⟨Ĵ⟩ ⟨Ĵ⟩ ⊢* Ĵ.qn.
>>>>
>>>>> The code is still there but the infinite cycle
>>>>> from Ĵ.qx to Ĵ.q0 prevents it from ever being reached.
>>>>
>>>> No.  You are totally at sea.  I did my best to explain but you'd
>>>> have to
>>>> want to learn to make any progress.
>>>>
>>>>>>      Ĵ.q0 ⟨Ĵ⟩ ⊢* Ĵ.qx ⟨Ĵ⟩ ⟨Ĵ⟩ ⊢* Ĵ.qn
>>>>>> The TM at Ĵ.qx is your "UTM-decider" with an unreachable reject
>>>>>> state.
>>>>>> Do you see why I don't think you know what you are saying?
>>>>>
>>>>> The you imagine what I mean to say instead of examining what I
>>>>> actually say is your mistake.
>>>>>
>>>>> This machine
>>>>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qn
>>>>>
>>>>> is transformed into this machine:
>>>>> Ĵ.q0 ⟨Ĵ⟩ ⊢* Ĵ.qx ⟨Ĵ⟩ ⟨Ĵ⟩ ⊢* Ĵ.qn // a machine stuck in
>>>>> infinitely nested simulation
>>>>
>>>> You don't know what this notation means.  I don't think I can help you
>>>> with this.
>>>>
>>>>>>>>>>> There is an infinite cycle from Ĵ.qx to Ĵ.q0.
>>>>>>>>>> No, but that's just because you've never written a UTM so you
>>>>>>>>>> don't know
>>>>>>>>>> how such a TM would work.  Ĵ applied to ⟨Ĵ⟩ is non-halting but
>>>>>>>>>> there
>>>>>>>>>> will not be a cycle from Ĵ.q0 -> Ĵ.qx -> Ĵ.q0...[1]
>>>>>>>>>>
>>>>>>>>>>> Ĵ.q0 ⟨Ĵ⟩ ⊢* Ĵ.qx ⟨Ĵ⟩ ⟨Ĵ⟩ ⊢* Ĵ.qn
>>>>>>>>>>
>>>>>>>>>> Eh?  You've just said that Ĵ applied to ⟨Ĵ⟩ is non-halting.
>>>>>> This needs to be addressed.
>>>>>
>>>>> That you don't believe that there is a cycle from Ĵ.qx to Ĵ.q0 is
>>>>> flatly wrong.
>>>>
>>>> No, I'm right about that.
>>>
>>> Try and exaplain how you are right about that.
>>
>> The fact that the code for J (or P) has absolutely no path to go from
>> the state qx to the state q0 OF THE SAME EXECUTION (which is what the
>> diagram is showing).
>>
>> Yes, there is a 'virtual' connection from qx of one invocation to a q0
>> of a simulated embedded invocation, but that state is NOT the outer q0.
>>
>> Turing Machine P or J NEVER go back to their own q0 state.
>>
>> You could perhaps say we have a nesting of
>>
>> P0.q0 -> P0.qx -> P1.q0 -> P1.qx ...
>>
>> But that is a NESTING, not a LOOP.
>>
>> They are different.
>
> None-the-less we have infinitely nested simulation that would never halt
> unless the simulating halt decider aborts its simulation of its input.

You HAVE to decide what your H is doing.

Either

1) H NEVER aborts the simulation, at which point Hn(<Hn^>, <Hn^>) never
returns an answer as is thus a failed decider

2) H Does abort the simulation so it can answer and then it turns out
that Ha^(<Ha^>) is a Halting computation.

The only way to have it both ways is for H to not be a computation,
(Which actually seems to be the case) in which case it also fails to be
a valid Halt Decider because it isn't the comptational equivalent of a
Turing Machine to be the Turing Machine H.

I think your problem is you just don't understand that last statement.

>
> This conclusively proves that the simulating halt decider at Ĥ.qx ⟨Ĥ1⟩
> ⟨Ĥ2⟩ must abort the simulation of this input which conclusively proves
> that this input never halts.
>

Nope. Just shows you don't know what you are talking about.

>>
>>>
>>>
>>>> But you are piling errors on errors now so
>>>> responding is getting harder.  What you are not responding to is the
>>>> contraction.  Even though there is no cycle from Ĵ.qx to Ĵ.q0, Ĵ
>>>> applied
>>>> to ⟨Ĵ⟩ is indeed non-halting you keep showing that it halts.  Even if
>>>> there were a cycle from Ĵ.qx to Ĵ.q0 you would still be contradicting
>>>> yourself.
>>>
>>
>
>

On 8/25/2021 7:11 PM, Richard Damon wrote:
> On 8/25/21 3:06 PM, olcott wrote:
>> On 8/25/2021 1:55 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 8/25/2021 10:56 AM, Ben Bacarisse wrote:
>>>
>>>>> The halting problem is about the existence of a TM that accept those
>>>>> string pairs (and only those string pairs) that encode halting
>>>>> computations.  All other strings are to be rejected.  The halting
>>>>> theorem states that no TM is a such a decider -- every TM fails to
>>>>> correctly classify at least one string pair.
>>>>>
>>>>> You claim to have a TM, unfortunately called H, which is a halt
>>>>> decider.
>>>>> (Yes, you sometimes deny it is a general halt decider but you keep
>>>>> quoting me saying your algorithm is one, so I presume you agree that it
>>>>> must be one.)
>>>
>>> So you are indeed claiming to have a general halt decider!  That's a
>>> grand boast!  (You need to say "no" if you don't want this to be taken
>>> as your real position.)
>>>
>>>>> You tell us, again and again, that the computation of Ĥ applied to the
>>>>> encoding of Ĥ (written ⟨Ĥ⟩) is a halting computation.  You are quick to
>>>>> jump in and say that it "only halts because... reason", but it's a
>>>>> halting computation whatever the reason.
>>>>>   That halting computation is encoded as the string pair ⟨Ĥ⟩ ⟨Ĥ⟩.  (I
>>>>> prefer a notation that makes the pairing of an encoded TM and some
>>>>> input
>>>>> explicit, but that boat sailed years ago.)
>>>>>   You also tell is that H rejects the string pair ⟨Ĥ⟩ ⟨Ĥ⟩.  I.e. you
>>>>> tell
>>>>> us everything we need to know to be sure that H is wrong about at least
>>>>> this one halting problem instance.
>>>>
>>>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qn
>>>>
>>>> Until you understand that the input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ is not a halting
>>>> computation there is no sense continuing this one way dialogue.
>>>
>>> Until you understand that ⟨Ĥ1⟩ ⟨Ĥ2⟩ equals ⟨Ĥ⟩ ⟨Ĥ⟩ and that ⟨Ĥ⟩ ⟨Ĥ⟩ is a
>>> string that should be accepted you are just blowing smoke.
>>>
>>
>> (a) While the simulating halt decider at Ĥ.qx remains in pure simulation
>> mode its input ⟨Ĥ1⟩ ⟨Ĥ2⟩ never halts.
>
> Because H happens to stop the simulation too soon.
>

Ĵ.q0 ⟨Ĥ1⟩ ⊢* Ĵ.qx ⟨Ĵ1⟩ ⟨Ĵ2⟩ ...

You are pretty intelligent to be able to catch the subtle nuance of how
Ĵ applied to ⟨Ĵ⟩ is not exactly a cycle from Ĵ.qx to Ĵ.q0 because these
are two different instances.

That is why it seems to me that you could only be playing head games
when you fail to acknowledge that Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ specifies infinitely
nested simulation that never stops unless the simulating halt decider at
Ĥ.qx aborts its simulation.

> Put that exact same input into a compatible UTM, and it will run to a Halt.
>
> THEREFORE, H WAS WRONG to abort the simulation and declair non-halting.
>
>
>>
>> (b) Every computation that never halts while its simulating halt decider
>> remains in pure simulation mode is a computation that never halts.
>
> FALSE STATEMENT. PERIOD>
>
>
>>
>> Too disingenuous to continue. You utterly refuse to directly examine my
>> proof provided immediately above that is not the sign of an honest
>> dialogue.
>>
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 8/25/21 1:11 PM, olcott wrote:
> On 8/25/2021 10:19 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 8/24/2021 7:35 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 8/24/2021 9:09 AM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 8/23/2021 10:09 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 8/23/2021 6:26 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>
>>>>>>>>>>> There is an infinite cycle from Ĵ.qx to Ĵ.q0.
>>>>>>>>>>
>>>>>>>>>> No, but that's just because you've never written a UTM so you
>>>>>>>>>> don't know
>>>>>>>>>> how such a TM would work.  Ĵ applied to ⟨Ĵ⟩ is non-halting but
>>>>>>>>>> there
>>>>>>>>>> will not be a cycle from Ĵ.q0 -> Ĵ.qx -> Ĵ.q0...[1]
>>>>>>>>>>
>>>>>>>>>>> Ĵ.q0 ⟨Ĵ⟩ ⊢* Ĵ.qx ⟨Ĵ⟩ ⟨Ĵ⟩ ⊢* Ĵ.qn
>>>>>>>>>>
>>>>>>>>>> Eh?  You've just said that Ĵ applied to ⟨Ĵ⟩ is non-halting.
>>>>>>
>>>>>> This needs to be addressed.
>>>>>
>>>>> That you don't believe that there is a cycle from Ĵ.qx to Ĵ.q0 is
>>>>> flatly wrong.
>>>>
>>>> No, I'm right about that.
>>>
>>> Try and exaplain how you are right about that.
>>
>> It follows directly from the "hat" construction.  The TM "at" Ĵ.qx is
>> (in effect) J.  None of entries in J's state transition function can
>> refer to state Ĵ.q0 because that is a new stated added (along with a few
>> others) with the sole purpose of doing the copy of the input.  There is
>> simply no path from Ĵ.qx to Ĵ.q0.
>>
>
> There is a path from Ĵ.qx to the Ĵ.q0 of another instance.
> infinitely nested simulation with copying is a little less like infinite
> recursion than infinitely nested simulation without copying,
> none-the-less it is still obviously infinite.

Except that notation is of a SINGLE instance.

>
>> And, similarly, since J is a UTM with only an accepting state (qy) the
>> line you keep writing
>>
>>    Ĵ.q0 ⟨Ĵ⟩ ⊢* Ĵ.qx ⟨Ĵ⟩ ⟨Ĵ⟩ ⊢* Ĵ.qn
>>
>> is bogus. 
>
> Like I said before it is not bogus. A machine can possibly be defined
> with unreachable states. When Ĥ is converted to Ĵ by a single change to
> Ĥ this new Ĵ has unreachable states.
>
> I wanted to make a single change to Ĥ to derive Ĵ to make the single
> point that Ĥ never stops running unless its aborts the simulation of its
> input at Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ thus conclusively proving that this input never
> halts according to this criteria:
>
> Simulating Halt Decider Theorem (Olcott 2020):
> A simulating halt decider correctly decides that any input that never
> halts unless the simulating halt decider aborts its simulation of this
> input is an input that never halts.
>

A FALSE Theorem.

> Although I call it a theorem it is actually a little stronger than that
> because it is self-evidently true.

Nope. It VIOLATES the definition of Halting.

Maybe YOU are the UNSOUND piece.

It is only a Peter Olcott evident 'truth', but it is actually false.

>
> the·o·rem
> /ˈTHēərəm,ˈTHirəm/
> a general proposition not self-evident but proved by a chain of
> reasoning; a truth established by means of accepted truths.
>
>> You can add states to a TM at will, so J or Ĵ can be
>> (pointlessly) given a rejecting state qn, but there can't be any
>> configuration sequences that end in it.
>>
>
> Of course it is the case that any states following infinitely nested
> simulation will never be reached. I knew that when I derived the
> specification for Ĵ by making a single change to Ĥ.
>

Except that it isn't infinitely nested, at least if H does return the
non-halting answer. Your 'analysis' uses flawed logic, and is thus UNSOUND.

> You seems to have trouble with more than one step so I limited my change
> to a single step.

You seem to have a problem accepting actual truth.

>
>> And the line is bogus for another reason.  You are correct that Ĵ
>> applied to ⟨Ĵ⟩ is non-halting (thought not because of the cycle you
>> imagine was there) and this line directly contradicts that fact.  You
>> need to write
>>
>
> There is a cycle following Ĵ.qx ⟨Ĵ⟩ ⟨Ĵ⟩ to another instance of Ĵ.q0.
> It is a cycle within the Ĵ template.

No, it is NOT withing the 'template'

Yes, J^ will be an infinite computation. But J^ isn't H^ so the answer
doesn't transfer.

Maybe only in your broken logic system where you have introduced false
truths so nothing works right.

>
> Ĵ copies its input ⟨Ĵ1⟩ to ⟨Ĵ2⟩ then
> simulates this input Ĵ1 with its input ⟨Ĵ2⟩
>
> which copies its input ⟨Ĵ2⟩ to ⟨Ĵ3⟩ then
> simulates this input Ĵ2 with its input ⟨Ĵ3⟩
>
> which copies its input ⟨Ĵ3⟩ to ⟨Ĵ4⟩ then...
>
>
>>    Ĵ.q0 ⟨Ĵ⟩ ⊢* Ĵ.qx ⟨Ĵ⟩ ⟨Ĵ⟩ ⊢* ∞
>>
>> or, if you don't need to show the one and only literal string copying
>> step, just Ĵ.q0 ⟨Ĵ⟩ ⊢* ∞.
>>
>
>

On 8/25/2021 7:15 PM, Richard Damon wrote:
> On 8/25/21 10:15 AM, olcott wrote:
>> On 8/25/2021 7:19 AM, Richard Damon wrote:
>>> On 8/24/21 11:53 PM, olcott wrote:
>>>> On 8/24/2021 7:35 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 8/24/2021 9:09 AM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 8/23/2021 10:09 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 8/23/2021 6:26 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 8/23/2021 2:30 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> I ignore dishonest dodges away from the point at hand.
>>>>>>>>>>> OK, let's do that:
>>>>>>>>>>>        "⟨Ĥ⟩ ⟨Ĥ⟩ is not a string that encodes a halting
>>>>>>>>>>> computation"
>>>>>>>>>>> is wrong.  You wrote that immediately after a line showing that Ĥ
>>>>>>>>>>> applied to ⟨Ĥ⟩ halts.  Everything since then has just been
>>>>>>>>>>> dodging this
>>>>>>>>>>> error.
>>>>>>>>>>>
>>>>>>>>>>>> When we define Ĵ to be exactly like Ĥ except that it has a UTM
>>>>>>>>>>>> at Ĵ.qx
>>>>>>>>>>>> instead of a simulating halt decider then we can see that Ĵ
>>>>>>>>>>>> applied to
>>>>>>>>>>>> ⟨Ĵ⟩ never halts.
>>>>>>>>>>> The details are mess, but basically, yes.  Detail errors (that
>>>>>>>>>>> would get
>>>>>>>>>>> your paper rejected out of hand) available if you ask really
>>>>>>>>>>> nicely.
>>>>>>>>>>
>>>>>>>>>> Which details do you think are incorrect?
>>>>>>>>>
>>>>>>>>> A UTM is not a decider so the hat construction can't be applied to
>>>>>>>>> it.
>>>>>>>>> And if we make a "UTM-decider" (a TM that is a pure simulator
>>>>>>>>> except
>>>>>>>>> that is accepts those computations whose simulations terminate) we
>>>>>>>>> still
>>>>>>>>> can't apply the hat construction because it won't have a rejecting
>>>>>>>>> state.  Thus your use of "exactly like Ĥ except..." is, at best,
>>>>>>>>> disingenuous.  The differences must be greater than the "except..."
>>>>>>>>> clause suggests.
>>>>>>>>
>>>>>>>> My whole purpose was to simply show what happens when the simulating
>>>>>>>> halt decide at Ĥ.qx only simulates its input.
>>>>>>> I know, but you wanted to know what details you'd got wrong.
>>>>>>>
>>>>>>
>>>>>> If my plan was to swap the simulating halt decider at Ĥ.qx with a UTM
>>>>>> and then rename this machine to Ĵ and I did swap swap the simulating
>>>>>> halt decider at Ĥ.qx with a UTM and rename this machine to Ĵ then it
>>>>>> is a God damned lie that I got anything wrong.
>>>>>
>>>>> No.  You won't get it unless you really try.
>>>>>
>>>>>>>> We can still have the same final states, except now that are
>>>>>>>> unreachable dead code.
>>>>>>> Except you show below this unreachable state being reached:
>>>>>>
>>>>>> No I do frigging not.
>>>>>
>>>>> Yes you did.  I quoted you: Ĵ.q0 ⟨Ĵ⟩ ⊢* Ĵ.qx ⟨Ĵ⟩ ⟨Ĵ⟩ ⊢* Ĵ.qn.
>>>>>
>>>>>> The code is still there but the infinite cycle
>>>>>> from Ĵ.qx to Ĵ.q0 prevents it from ever being reached.
>>>>>
>>>>> No.  You are totally at sea.  I did my best to explain but you'd
>>>>> have to
>>>>> want to learn to make any progress.
>>>>>
>>>>>>>      Ĵ.q0 ⟨Ĵ⟩ ⊢* Ĵ.qx ⟨Ĵ⟩ ⟨Ĵ⟩ ⊢* Ĵ.qn
>>>>>>> The TM at Ĵ.qx is your "UTM-decider" with an unreachable reject
>>>>>>> state.
>>>>>>> Do you see why I don't think you know what you are saying?
>>>>>>
>>>>>> The you imagine what I mean to say instead of examining what I
>>>>>> actually say is your mistake.
>>>>>>
>>>>>> This machine
>>>>>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> is transformed into this machine:
>>>>>> Ĵ.q0 ⟨Ĵ⟩ ⊢* Ĵ.qx ⟨Ĵ⟩ ⟨Ĵ⟩ ⊢* Ĵ.qn // a machine stuck in
>>>>>> infinitely nested simulation
>>>>>
>>>>> You don't know what this notation means.  I don't think I can help you
>>>>> with this.
>>>>>
>>>>>>>>>>>> There is an infinite cycle from Ĵ.qx to Ĵ.q0.
>>>>>>>>>>> No, but that's just because you've never written a UTM so you
>>>>>>>>>>> don't know
>>>>>>>>>>> how such a TM would work.  Ĵ applied to ⟨Ĵ⟩ is non-halting but
>>>>>>>>>>> there
>>>>>>>>>>> will not be a cycle from Ĵ.q0 -> Ĵ.qx -> Ĵ.q0...[1]
>>>>>>>>>>>
>>>>>>>>>>>> Ĵ.q0 ⟨Ĵ⟩ ⊢* Ĵ.qx ⟨Ĵ⟩ ⟨Ĵ⟩ ⊢* Ĵ.qn
>>>>>>>>>>>
>>>>>>>>>>> Eh?  You've just said that Ĵ applied to ⟨Ĵ⟩ is non-halting.
>>>>>>> This needs to be addressed.
>>>>>>
>>>>>> That you don't believe that there is a cycle from Ĵ.qx to Ĵ.q0 is
>>>>>> flatly wrong.
>>>>>
>>>>> No, I'm right about that.
>>>>
>>>> Try and exaplain how you are right about that.
>>>
>>> The fact that the code for J (or P) has absolutely no path to go from
>>> the state qx to the state q0 OF THE SAME EXECUTION (which is what the
>>> diagram is showing).
>>>
>>> Yes, there is a 'virtual' connection from qx of one invocation to a q0
>>> of a simulated embedded invocation, but that state is NOT the outer q0.
>>>
>>> Turing Machine P or J NEVER go back to their own q0 state.
>>>
>>> You could perhaps say we have a nesting of
>>>
>>> P0.q0 -> P0.qx -> P1.q0 -> P1.qx ...
>>>
>>> But that is a NESTING, not a LOOP.
>>>
>>> They are different.
>>
>> None-the-less we have infinitely nested simulation that would never halt
>> unless the simulating halt decider aborts its simulation of its input.
>
> You HAVE to decide what your H is doing.
>

When we define Ĵ to be exactly like Ĥ except that it has a UTM at Ĵ.qx
instead of a simulating halt decider then we can see that Ĵ applied to
⟨Ĵ⟩ never halts.

Ĵ copies its input ⟨Ĵ1⟩ to ⟨Ĵ2⟩ then simulates this input Ĵ1 with its
input ⟨Ĵ2⟩
which copies its input ⟨Ĵ2⟩ to ⟨Ĵ3⟩ then simulates this input Ĵ2 with
its input ⟨Ĵ3⟩
which copies its input ⟨Ĵ3⟩ to ⟨Ĵ4⟩ then simulates this input Ĵ3 with
its input ⟨Ĵ4⟩ ...

With the Peter Linz Ĥ we have exactly the same thing while the
simulating halt decider at Ĥ.qx remains in simulation mode.

Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qy ∞
if the simulated ⟨Ĥ1⟩ applied to ⟨Ĥ2⟩ halts, and

On 8/25/2021 7:22 PM, Richard Damon wrote:
> On 8/25/21 1:11 PM, olcott wrote:
>> On 8/25/2021 10:19 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 8/24/2021 7:35 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 8/24/2021 9:09 AM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 8/23/2021 10:09 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 8/23/2021 6:26 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>>>>>>>>>> There is an infinite cycle from Ĵ.qx to Ĵ.q0.
>>>>>>>>>>>
>>>>>>>>>>> No, but that's just because you've never written a UTM so you
>>>>>>>>>>> don't know
>>>>>>>>>>> how such a TM would work.  Ĵ applied to ⟨Ĵ⟩ is non-halting but
>>>>>>>>>>> there
>>>>>>>>>>> will not be a cycle from Ĵ.q0 -> Ĵ.qx -> Ĵ.q0...[1]
>>>>>>>>>>>
>>>>>>>>>>>> Ĵ.q0 ⟨Ĵ⟩ ⊢* Ĵ.qx ⟨Ĵ⟩ ⟨Ĵ⟩ ⊢* Ĵ.qn
>>>>>>>>>>>
>>>>>>>>>>> Eh?  You've just said that Ĵ applied to ⟨Ĵ⟩ is non-halting.
>>>>>>>
>>>>>>> This needs to be addressed.
>>>>>>
>>>>>> That you don't believe that there is a cycle from Ĵ.qx to Ĵ.q0 is
>>>>>> flatly wrong.
>>>>>
>>>>> No, I'm right about that.
>>>>
>>>> Try and exaplain how you are right about that.
>>>
>>> It follows directly from the "hat" construction.  The TM "at" Ĵ.qx is
>>> (in effect) J.  None of entries in J's state transition function can
>>> refer to state Ĵ.q0 because that is a new stated added (along with a few
>>> others) with the sole purpose of doing the copy of the input.  There is
>>> simply no path from Ĵ.qx to Ĵ.q0.
>>>
>>
>> There is a path from Ĵ.qx to the Ĵ.q0 of another instance.
>> infinitely nested simulation with copying is a little less like infinite
>> recursion than infinitely nested simulation without copying,
>> none-the-less it is still obviously infinite.
>
> Except that notation is of a SINGLE instance.
>
>>
>>> And, similarly, since J is a UTM with only an accepting state (qy) the
>>> line you keep writing
>>>
>>>    Ĵ.q0 ⟨Ĵ⟩ ⊢* Ĵ.qx ⟨Ĵ⟩ ⟨Ĵ⟩ ⊢* Ĵ.qn
>>>
>>> is bogus.
>>
>> Like I said before it is not bogus. A machine can possibly be defined
>> with unreachable states. When Ĥ is converted to Ĵ by a single change to
>> Ĥ this new Ĵ has unreachable states.
>>
>> I wanted to make a single change to Ĥ to derive Ĵ to make the single
>> point that Ĥ never stops running unless its aborts the simulation of its
>> input at Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ thus conclusively proving that this input never
>> halts according to this criteria:
>>
>> Simulating Halt Decider Theorem (Olcott 2020):
>> A simulating halt decider correctly decides that any input that never
>> halts unless the simulating halt decider aborts its simulation of this
>> input is an input that never halts.
>>
>
>
> A FALSE Theorem.
>
>> Although I call it a theorem it is actually a little stronger than that
>> because it is self-evidently true.
>
> Nope. It VIOLATES the definition of Halting.

It correctly decides conventional halting and conventional never halting
inputs on the basis of the definition of a UTM.

Do you understand this much or should I give up on you too?

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 8/25/21 8:22 PM, olcott wrote:
> On 8/25/2021 7:11 PM, Richard Damon wrote:
>> On 8/25/21 3:06 PM, olcott wrote:
>>> On 8/25/2021 1:55 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 8/25/2021 10:56 AM, Ben Bacarisse wrote:
>>>>
>>>>>> The halting problem is about the existence of a TM that accept those
>>>>>> string pairs (and only those string pairs) that encode halting
>>>>>> computations.  All other strings are to be rejected.  The halting
>>>>>> theorem states that no TM is a such a decider -- every TM fails to
>>>>>> correctly classify at least one string pair.
>>>>>>
>>>>>> You claim to have a TM, unfortunately called H, which is a halt
>>>>>> decider.
>>>>>> (Yes, you sometimes deny it is a general halt decider but you keep
>>>>>> quoting me saying your algorithm is one, so I presume you agree
>>>>>> that it
>>>>>> must be one.)
>>>>
>>>> So you are indeed claiming to have a general halt decider!  That's a
>>>> grand boast!  (You need to say "no" if you don't want this to be taken
>>>> as your real position.)
>>>>
>>>>>> You tell us, again and again, that the computation of Ĥ applied to
>>>>>> the
>>>>>> encoding of Ĥ (written ⟨Ĥ⟩) is a halting computation.  You are
>>>>>> quick to
>>>>>> jump in and say that it "only halts because... reason", but it's a
>>>>>> halting computation whatever the reason.
>>>>>>    That halting computation is encoded as the string pair ⟨Ĥ⟩
>>>>>> ⟨Ĥ⟩.  (I
>>>>>> prefer a notation that makes the pairing of an encoded TM and some
>>>>>> input
>>>>>> explicit, but that boat sailed years ago.)
>>>>>>    You also tell is that H rejects the string pair ⟨Ĥ⟩ ⟨Ĥ⟩.  I.e. you
>>>>>> tell
>>>>>> us everything we need to know to be sure that H is wrong about at
>>>>>> least
>>>>>> this one halting problem instance.
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qn
>>>>>
>>>>> Until you understand that the input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ is not a halting
>>>>> computation there is no sense continuing this one way dialogue.
>>>>
>>>> Until you understand that ⟨Ĥ1⟩ ⟨Ĥ2⟩ equals ⟨Ĥ⟩ ⟨Ĥ⟩ and that ⟨Ĥ⟩ ⟨Ĥ⟩
>>>> is a
>>>> string that should be accepted you are just blowing smoke.
>>>>
>>>
>>> (a) While the simulating halt decider at Ĥ.qx remains in pure simulation
>>> mode its input ⟨Ĥ1⟩ ⟨Ĥ2⟩ never halts.
>>
>> Because H happens to stop the simulation too soon.
>>
>
> Ĵ.q0 ⟨Ĥ1⟩ ⊢* Ĵ.qx ⟨Ĵ1⟩ ⟨Ĵ2⟩ ...
>
> You are pretty intelligent to be able to catch the subtle nuance of how
> Ĵ applied to ⟨Ĵ⟩ is not exactly a cycle from Ĵ.qx to Ĵ.q0 because these
> are two different instances.
>
> That is why it seems to me that you could only be playing head games
> when you fail to acknowledge that Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ specifies infinitely
> nested simulation that never stops unless the simulating halt decider at
> Ĥ.qx aborts its simulation.

You keep using that phrase, which doesn't really mean what you think it
does. 'unless' isn't really applicable here, it REALLY generates some
distinct cases.

H DOESN'T abort the simulation, in which case Hn(<Hn^>,<Hn^>) never
returns an answer, so Hn isn't a correct halt decider because it didn't
decide the case.

H DOES abort the simulation, and return Non-Halting, in which case your
logic fails as you assume in your simulation that your Ha won't abort
it's simulation, and thus you used UNSOUND logic. It is also easy to
prove by just running it or using a REAL UTM, that Ha^(<Ha^>) is a
Halting computation, thus Ha is also WRONG.

The last possibility is that H just isn't a computation, and thus it
fails to be a computation equivalent of the H of the proof, so nothing
after that means anything.

Remember, to even START the claim of having a decider that refutes these
proofs, your H must be algorithmically defined so as to be a real
Computation per the definion of Computation Theory. It seems that your H
doesn't meet that requrement, as you keep on trying to make proofs based
on trying different ones. This is really just like the proof that you
are trying to disprove, and the fact that your H gets the wrong answer
just reinforces those proofs.

>
>
>> Put that exact same input into a compatible UTM, and it will run to a
>> Halt.
>>
>> THEREFORE, H WAS WRONG to abort the simulation and declair non-halting.
>>
>>
>>>
>>> (b) Every computation that never halts while its simulating halt decider
>>> remains in pure simulation mode is a computation that never halts.
>>
>> FALSE STATEMENT. PERIOD>
>>
>>
>>>
>>> Too disingenuous to continue. You utterly refuse to directly examine my
>>> proof provided immediately above that is not the sign of an honest
>>> dialogue.
>>>
>>
>
>

On 8/25/21 8:41 PM, olcott wrote:
> On 8/25/2021 7:22 PM, Richard Damon wrote:
>> On 8/25/21 1:11 PM, olcott wrote:
>>> On 8/25/2021 10:19 AM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 8/24/2021 7:35 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 8/24/2021 9:09 AM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 8/23/2021 10:09 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 8/23/2021 6:26 PM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>>>>>>>>>> There is an infinite cycle from Ĵ.qx to Ĵ.q0.
>>>>>>>>>>>>
>>>>>>>>>>>> No, but that's just because you've never written a UTM so you
>>>>>>>>>>>> don't know
>>>>>>>>>>>> how such a TM would work.  Ĵ applied to ⟨Ĵ⟩ is non-halting but
>>>>>>>>>>>> there
>>>>>>>>>>>> will not be a cycle from Ĵ.q0 -> Ĵ.qx -> Ĵ.q0...[1]
>>>>>>>>>>>>
>>>>>>>>>>>>> Ĵ.q0 ⟨Ĵ⟩ ⊢* Ĵ.qx ⟨Ĵ⟩ ⟨Ĵ⟩ ⊢* Ĵ.qn
>>>>>>>>>>>>
>>>>>>>>>>>> Eh?  You've just said that Ĵ applied to ⟨Ĵ⟩ is non-halting.
>>>>>>>>
>>>>>>>> This needs to be addressed.
>>>>>>>
>>>>>>> That you don't believe that there is a cycle from Ĵ.qx to Ĵ.q0 is
>>>>>>> flatly wrong.
>>>>>>
>>>>>> No, I'm right about that.
>>>>>
>>>>> Try and exaplain how you are right about that.
>>>>
>>>> It follows directly from the "hat" construction.  The TM "at" Ĵ.qx is
>>>> (in effect) J.  None of entries in J's state transition function can
>>>> refer to state Ĵ.q0 because that is a new stated added (along with a
>>>> few
>>>> others) with the sole purpose of doing the copy of the input.  There is
>>>> simply no path from Ĵ.qx to Ĵ.q0.
>>>>
>>>
>>> There is a path from Ĵ.qx to the Ĵ.q0 of another instance.
>>> infinitely nested simulation with copying is a little less like infinite
>>> recursion than infinitely nested simulation without copying,
>>> none-the-less it is still obviously infinite.
>>
>> Except that notation is of a SINGLE instance.
>>
>>>
>>>> And, similarly, since J is a UTM with only an accepting state (qy) the
>>>> line you keep writing
>>>>
>>>>     Ĵ.q0 ⟨Ĵ⟩ ⊢* Ĵ.qx ⟨Ĵ⟩ ⟨Ĵ⟩ ⊢* Ĵ.qn
>>>>
>>>> is bogus.
>>>
>>> Like I said before it is not bogus. A machine can possibly be defined
>>> with unreachable states. When Ĥ is converted to Ĵ by a single change to
>>> Ĥ this new Ĵ has unreachable states.
>>>
>>> I wanted to make a single change to Ĥ to derive Ĵ to make the single
>>> point that Ĥ never stops running unless its aborts the simulation of its
>>> input at Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ thus conclusively proving that this input never
>>> halts according to this criteria:
>>>
>>> Simulating Halt Decider Theorem (Olcott 2020):
>>> A simulating halt decider correctly decides that any input that never
>>> halts unless the simulating halt decider aborts its simulation of this
>>> input is an input that never halts.
>>>
>>
>>
>> A FALSE Theorem.
>>
>>> Although I call it a theorem it is actually a little stronger than that
>>> because it is self-evidently true.
>>
>> Nope. It VIOLATES the definition of Halting.
>
> It correctly decides conventional halting and conventional never halting
> inputs on the basis of the definition of a UTM.
>
> Do you understand this much or should I give up on you too?
>
>
No, becuase UTM(<H^>, <H^>) Halts, thus showing that since H(<H^>,<H^>)
says non-halting it was wrong.

Remember, your 'acts like a UTM until it decides and the it aborts it
simulation' means that H is NOT a UTM.

If you act like a student until your complete your course of study, then
you are a Graduate.
If you act like a student until you give up, you are not, you are just a
drop-out.

If a simulator completes its work when its simulation reaches a halting
state, then it is a UTM,
A simulator that stops earlier isn't a UTM, it is just a drop-out.

In that later context 'Pure' isn't really an applicable adjective, as it
is an absolute qualifier. That is like calling someone who is currently
living as being 'like an immortal'. It just isn't true.

On 8/25/2021 8:21 PM, Richard Damon wrote:
> On 8/25/21 8:22 PM, olcott wrote:
>> On 8/25/2021 7:11 PM, Richard Damon wrote:
>>> On 8/25/21 3:06 PM, olcott wrote:
>>>> On 8/25/2021 1:55 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 8/25/2021 10:56 AM, Ben Bacarisse wrote:
>>>>>
>>>>>>> The halting problem is about the existence of a TM that accept those
>>>>>>> string pairs (and only those string pairs) that encode halting
>>>>>>> computations.  All other strings are to be rejected.  The halting
>>>>>>> theorem states that no TM is a such a decider -- every TM fails to
>>>>>>> correctly classify at least one string pair.
>>>>>>>
>>>>>>> You claim to have a TM, unfortunately called H, which is a halt
>>>>>>> decider.
>>>>>>> (Yes, you sometimes deny it is a general halt decider but you keep
>>>>>>> quoting me saying your algorithm is one, so I presume you agree
>>>>>>> that it
>>>>>>> must be one.)
>>>>>
>>>>> So you are indeed claiming to have a general halt decider!  That's a
>>>>> grand boast!  (You need to say "no" if you don't want this to be taken
>>>>> as your real position.)
>>>>>
>>>>>>> You tell us, again and again, that the computation of Ĥ applied to
>>>>>>> the
>>>>>>> encoding of Ĥ (written ⟨Ĥ⟩) is a halting computation.  You are
>>>>>>> quick to
>>>>>>> jump in and say that it "only halts because... reason", but it's a
>>>>>>> halting computation whatever the reason.
>>>>>>>    That halting computation is encoded as the string pair ⟨Ĥ⟩
>>>>>>> ⟨Ĥ⟩.  (I
>>>>>>> prefer a notation that makes the pairing of an encoded TM and some
>>>>>>> input
>>>>>>> explicit, but that boat sailed years ago.)
>>>>>>>    You also tell is that H rejects the string pair ⟨Ĥ⟩ ⟨Ĥ⟩.  I.e. you
>>>>>>> tell
>>>>>>> us everything we need to know to be sure that H is wrong about at
>>>>>>> least
>>>>>>> this one halting problem instance.
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> Until you understand that the input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ is not a halting
>>>>>> computation there is no sense continuing this one way dialogue.
>>>>>
>>>>> Until you understand that ⟨Ĥ1⟩ ⟨Ĥ2⟩ equals ⟨Ĥ⟩ ⟨Ĥ⟩ and that ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>> is a
>>>>> string that should be accepted you are just blowing smoke.
>>>>>
>>>>
>>>> (a) While the simulating halt decider at Ĥ.qx remains in pure simulation
>>>> mode its input ⟨Ĥ1⟩ ⟨Ĥ2⟩ never halts.
>>>
>>> Because H happens to stop the simulation too soon.
>>>
>>
>> Ĵ.q0 ⟨Ĥ1⟩ ⊢* Ĵ.qx ⟨Ĵ1⟩ ⟨Ĵ2⟩ ...
>>
>> You are pretty intelligent to be able to catch the subtle nuance of how
>> Ĵ applied to ⟨Ĵ⟩ is not exactly a cycle from Ĵ.qx to Ĵ.q0 because these
>> are two different instances.
>>
>> That is why it seems to me that you could only be playing head games
>> when you fail to acknowledge that Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ specifies infinitely
>> nested simulation that never stops unless the simulating halt decider at
>> Ĥ.qx aborts its simulation.
>
> You keep using that phrase, which doesn't really mean what you think it
> does. 'unless' isn't really applicable here, it REALLY generates some
> distinct cases.
This is what I really think that you are playing head games.

It is not that hard to imagine distinct cases:
(1) Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩... never aborts the simulation of its
input.

(2) Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩... aborts the simulation of its input at
some point.

You go around and around and around as if the difference between the two
cases is unfathomably difficult to comprehend.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 8/25/2021 8:28 PM, Richard Damon wrote:
> On 8/25/21 8:41 PM, olcott wrote:
>> On 8/25/2021 7:22 PM, Richard Damon wrote:
>>> On 8/25/21 1:11 PM, olcott wrote:
>>>> On 8/25/2021 10:19 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 8/24/2021 7:35 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 8/24/2021 9:09 AM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 8/23/2021 10:09 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 8/23/2021 6:26 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>>>>>>>>>> There is an infinite cycle from Ĵ.qx to Ĵ.q0.
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, but that's just because you've never written a UTM so you
>>>>>>>>>>>>> don't know
>>>>>>>>>>>>> how such a TM would work.  Ĵ applied to ⟨Ĵ⟩ is non-halting but
>>>>>>>>>>>>> there
>>>>>>>>>>>>> will not be a cycle from Ĵ.q0 -> Ĵ.qx -> Ĵ.q0...[1]
>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĵ.q0 ⟨Ĵ⟩ ⊢* Ĵ.qx ⟨Ĵ⟩ ⟨Ĵ⟩ ⊢* Ĵ.qn
>>>>>>>>>>>>>
>>>>>>>>>>>>> Eh?  You've just said that Ĵ applied to ⟨Ĵ⟩ is non-halting.
>>>>>>>>>
>>>>>>>>> This needs to be addressed.
>>>>>>>>
>>>>>>>> That you don't believe that there is a cycle from Ĵ.qx to Ĵ.q0 is
>>>>>>>> flatly wrong.
>>>>>>>
>>>>>>> No, I'm right about that.
>>>>>>
>>>>>> Try and exaplain how you are right about that.
>>>>>
>>>>> It follows directly from the "hat" construction.  The TM "at" Ĵ.qx is
>>>>> (in effect) J.  None of entries in J's state transition function can
>>>>> refer to state Ĵ.q0 because that is a new stated added (along with a
>>>>> few
>>>>> others) with the sole purpose of doing the copy of the input.  There is
>>>>> simply no path from Ĵ.qx to Ĵ.q0.
>>>>>
>>>>
>>>> There is a path from Ĵ.qx to the Ĵ.q0 of another instance.
>>>> infinitely nested simulation with copying is a little less like infinite
>>>> recursion than infinitely nested simulation without copying,
>>>> none-the-less it is still obviously infinite.
>>>
>>> Except that notation is of a SINGLE instance.
>>>
>>>>
>>>>> And, similarly, since J is a UTM with only an accepting state (qy) the
>>>>> line you keep writing
>>>>>
>>>>>     Ĵ.q0 ⟨Ĵ⟩ ⊢* Ĵ.qx ⟨Ĵ⟩ ⟨Ĵ⟩ ⊢* Ĵ.qn
>>>>>
>>>>> is bogus.
>>>>
>>>> Like I said before it is not bogus. A machine can possibly be defined
>>>> with unreachable states. When Ĥ is converted to Ĵ by a single change to
>>>> Ĥ this new Ĵ has unreachable states.
>>>>
>>>> I wanted to make a single change to Ĥ to derive Ĵ to make the single
>>>> point that Ĥ never stops running unless its aborts the simulation of its
>>>> input at Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ thus conclusively proving that this input never
>>>> halts according to this criteria:
>>>>
>>>> Simulating Halt Decider Theorem (Olcott 2020):
>>>> A simulating halt decider correctly decides that any input that never
>>>> halts unless the simulating halt decider aborts its simulation of this
>>>> input is an input that never halts.
>>>>
>>>
>>>
>>> A FALSE Theorem.
>>>
>>>> Although I call it a theorem it is actually a little stronger than that
>>>> because it is self-evidently true.
>>>
>>> Nope. It VIOLATES the definition of Halting.
>>
>> It correctly decides conventional halting and conventional never halting
>> inputs on the basis of the definition of a UTM.
>>
>> Do you understand this much or should I give up on you too?
>>
>>
> No, becuase UTM(<H^>, <H^>) Halts, thus showing that since H(<H^>,<H^>)
> says non-halting it was wrong.

That was your last chance.

>
> Remember, your 'acts like a UTM until it decides and the it aborts it
> simulation' means that H is NOT a UTM.
>
> If you act like a student until your complete your course of study, then
> you are a Graduate.
> If you act like a student until you give up, you are not, you are just a
> drop-out.
>
> If a simulator completes its work when its simulation reaches a halting
> state, then it is a UTM,
> A simulator that stops earlier isn't a UTM, it is just a drop-out.
>
> In that later context 'Pure' isn't really an applicable adjective, as it
> is an absolute qualifier. That is like calling someone who is currently
> living as being 'like an immortal'. It just isn't true.
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 8/25/21 9:31 PM, olcott wrote:
> On 8/25/2021 8:21 PM, Richard Damon wrote:
>> On 8/25/21 8:22 PM, olcott wrote:
>>> On 8/25/2021 7:11 PM, Richard Damon wrote:
>>>> On 8/25/21 3:06 PM, olcott wrote:
>>>>> On 8/25/2021 1:55 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 8/25/2021 10:56 AM, Ben Bacarisse wrote:
>>>>>>
>>>>>>>> The halting problem is about the existence of a TM that accept
>>>>>>>> those
>>>>>>>> string pairs (and only those string pairs) that encode halting
>>>>>>>> computations.  All other strings are to be rejected.  The halting
>>>>>>>> theorem states that no TM is a such a decider -- every TM fails to
>>>>>>>> correctly classify at least one string pair.
>>>>>>>>
>>>>>>>> You claim to have a TM, unfortunately called H, which is a halt
>>>>>>>> decider.
>>>>>>>> (Yes, you sometimes deny it is a general halt decider but you keep
>>>>>>>> quoting me saying your algorithm is one, so I presume you agree
>>>>>>>> that it
>>>>>>>> must be one.)
>>>>>>
>>>>>> So you are indeed claiming to have a general halt decider!  That's a
>>>>>> grand boast!  (You need to say "no" if you don't want this to be
>>>>>> taken
>>>>>> as your real position.)
>>>>>>
>>>>>>>> You tell us, again and again, that the computation of Ĥ applied to
>>>>>>>> the
>>>>>>>> encoding of Ĥ (written ⟨Ĥ⟩) is a halting computation.  You are
>>>>>>>> quick to
>>>>>>>> jump in and say that it "only halts because... reason", but it's a
>>>>>>>> halting computation whatever the reason.
>>>>>>>>     That halting computation is encoded as the string pair ⟨Ĥ⟩
>>>>>>>> ⟨Ĥ⟩.  (I
>>>>>>>> prefer a notation that makes the pairing of an encoded TM and some
>>>>>>>> input
>>>>>>>> explicit, but that boat sailed years ago.)
>>>>>>>>     You also tell is that H rejects the string pair ⟨Ĥ⟩ ⟨Ĥ⟩. 
>>>>>>>> I.e. you
>>>>>>>> tell
>>>>>>>> us everything we need to know to be sure that H is wrong about at
>>>>>>>> least
>>>>>>>> this one halting problem instance.
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qn
>>>>>>>
>>>>>>> Until you understand that the input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ is not a
>>>>>>> halting
>>>>>>> computation there is no sense continuing this one way dialogue.
>>>>>>
>>>>>> Until you understand that ⟨Ĥ1⟩ ⟨Ĥ2⟩ equals ⟨Ĥ⟩ ⟨Ĥ⟩ and that ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>> is a
>>>>>> string that should be accepted you are just blowing smoke.
>>>>>>
>>>>>
>>>>> (a) While the simulating halt decider at Ĥ.qx remains in pure
>>>>> simulation
>>>>> mode its input ⟨Ĥ1⟩ ⟨Ĥ2⟩ never halts.
>>>>
>>>> Because H happens to stop the simulation too soon.
>>>>
>>>
>>> Ĵ.q0 ⟨Ĥ1⟩ ⊢* Ĵ.qx ⟨Ĵ1⟩ ⟨Ĵ2⟩ ...
>>>
>>> You are pretty intelligent to be able to catch the subtle nuance of how
>>> Ĵ applied to ⟨Ĵ⟩ is not exactly a cycle from Ĵ.qx to Ĵ.q0 because these
>>> are two different instances.
>>>
>>> That is why it seems to me that you could only be playing head games
>>> when you fail to acknowledge that Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ specifies infinitely
>>> nested simulation that never stops unless the simulating halt decider at
>>> Ĥ.qx aborts its simulation.
>>
>> You keep using that phrase, which doesn't really mean what you think it
>> does. 'unless' isn't really applicable here, it REALLY generates some
>> distinct cases.
> This is what I really think that you are playing head games.
>
> It is not that hard to imagine distinct cases:

Right, and they are DISTINCT.

> (1) Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩... never aborts the simulation of its
> input.
>
> (2) Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩... aborts the simulation of its input at
> some point.
>
> You go around and around and around as if the difference between the two
> cases is unfathomably difficult to comprehend.
>

(1) never answers Hn(Hn^,Hn^) so is wrong
(2) Ha^(Ha^) does halt, so Ha(Ha^,Ha^) saying not halting is wrong.

Since we have DIFFERENT H^s in the two distinct cases, you can't use
your 'proof' from case (1) to try to prove that H^ in case (2) is
non-halting.

THAT is your fundamental error.

Remember, H^ includes within its algorithm, a copy of the algorithm of
H, so changing H changes H^. You keep on trying to ignore that FACT.

On 8/25/21 9:34 PM, olcott wrote:
> On 8/25/2021 8:28 PM, Richard Damon wrote:

>> No, becuase UTM(<H^>, <H^>) Halts, thus showing that since H(<H^>,<H^>)
>> says non-halting it was wrong.
>
>
> That was your last chance.

You admit defeat?

On 8/25/2021 8:39 PM, Richard Damon wrote:
> On 8/25/21 9:34 PM, olcott wrote:
>> On 8/25/2021 8:28 PM, Richard Damon wrote:
>
>>> No, becuase UTM(<H^>, <H^>) Halts, thus showing that since H(<H^>,<H^>)
>>> says non-halting it was wrong.
>>
>>
>> That was your last chance.
>
> You admit defeat?
>

I acknowledge that you are an incorrigible jackass.
The review process moves to phase two.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 8/25/21 10:01 PM, olcott wrote:
> On 8/25/2021 8:39 PM, Richard Damon wrote:
>> On 8/25/21 9:34 PM, olcott wrote:
>>> On 8/25/2021 8:28 PM, Richard Damon wrote:
>>
>>>> No, becuase UTM(<H^>, <H^>) Halts, thus showing that since H(<H^>,<H^>)
>>>> says non-halting it was wrong.
>>>
>>>
>>> That was your last chance.
>>
>> You admit defeat?
>>
>
> I acknowledge that you are an incorrigible jackass.
> The review process moves to phase two.
>

What does that mean? You going to write the paper to submit to get your
rejection?

You have yet to show anywhere whre my basic objections are incorrect.

Your 'theorems' have been proved to be groundless and totally unsound.

You totally don't understand what you are righting about.

On 8/25/2021 9:04 PM, Richard Damon wrote:
> On 8/25/21 10:01 PM, olcott wrote:
>> On 8/25/2021 8:39 PM, Richard Damon wrote:
>>> On 8/25/21 9:34 PM, olcott wrote:
>>>> On 8/25/2021 8:28 PM, Richard Damon wrote:
>>>
>>>>> No, becuase UTM(<H^>, <H^>) Halts, thus showing that since H(<H^>,<H^>)
>>>>> says non-halting it was wrong.
>>>>
>>>>
>>>> That was your last chance.
>>>
>>> You admit defeat?
>>>
>>
>> I acknowledge that you are an incorrigible jackass.
>> The review process moves to phase two.
>>
>
> What does that mean? You going to write the paper to submit to get your
> rejection?
>
> You have yet to show anywhere whre my basic objections are incorrect.
>

You know full well that your "objections" are pure drivel.

> Your 'theorems' have been proved to be groundless and totally unsound.
>
> You totally don't understand what you are righting about.
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 8/25/2021 8:39 PM, Richard Damon wrote:
> On 8/25/21 9:34 PM, olcott wrote:
>> On 8/25/2021 8:28 PM, Richard Damon wrote:
>
>>> No, becuase UTM(<H^>, <H^>) Halts, thus showing that since H(<H^>,<H^>)
>>> says non-halting it was wrong.
>>
>>
>> That was your last chance.
>
> You admit defeat?
>

This sort of response provides substantial additional evidence that you
never had any honest dialogue in mind.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 8/25/21 10:22 PM, olcott wrote:
> On 8/25/2021 9:04 PM, Richard Damon wrote:
>> On 8/25/21 10:01 PM, olcott wrote:
>>> On 8/25/2021 8:39 PM, Richard Damon wrote:
>>>> On 8/25/21 9:34 PM, olcott wrote:
>>>>> On 8/25/2021 8:28 PM, Richard Damon wrote:
>>>>
>>>>>> No, becuase UTM(<H^>, <H^>) Halts, thus showing that since
>>>>>> H(<H^>,<H^>)
>>>>>> says non-halting it was wrong.
>>>>>
>>>>>
>>>>> That was your last chance.
>>>>
>>>> You admit defeat?
>>>>
>>>
>>> I acknowledge that you are an incorrigible jackass.
>>> The review process moves to phase two.
>>>
>>
>> What does that mean? You going to write the paper to submit to get your
>> rejection?
>>
>> You have yet to show anywhere whre my basic objections are incorrect.
>>
>
> You know full well that your "objections" are pure drivel.

No, I, and everyone else who is reading this will see that what I say
makes sense.

YOUR statements are the 'pure drivel'.

Please note that basically no one belives your statements and everyone
thinks you are wrong. While it is possible that you have discovered some
hidden secret, it is very unlikely. One key thing to ask yourself, what
grounds do I have to actually expect that I could come up with some
insite like that that no one else beleives.

Then you need to ask yourself, If I am right and everyone else is wrong,
what it the path to show that. That path is NOT being argumentative.
That just solidifies the opposition. Remember, if you are right and fail
to convince others, it is as good as you being wrong, as the idea will
die with you.

If you really don't have the skill to persuade others, what makes you
think you actually have the skill to have come up with something that novel.

Yes, there HAVE been people who came up with ideas that others thought
were crazy, but later they were convinced. The key here is that the
people that came up with them actually understood the fields they
created in, and were able to break down their ideas inot simpler pieces
and show people they were right.

This does NOT apply to you. You keep on showing that you don't
understand the basics of the field you claim to have had your great idea
in, this would tend to indicate that what you have isn't some great new
idea, but some mistake, and likely one that has been made before.

One other big thing to remember, is that when/if you do submit your
paper for review, there is a good chance that some review will do a
search on the subject, and bring up these discussions. EVERY point that
has been brought up and not answered will be seen as an error in your
paper, so you really do need to handle them.

Since you have yet to really answer ANY of the fundamental objections,
you have a lot of work before you.

>
>> Your 'theorems' have been proved to be groundless and totally unsound.
>>
>> You totally don't understand what you are righting about.
>>
>
>

On 8/25/21 10:28 PM, olcott wrote:
> On 8/25/2021 8:39 PM, Richard Damon wrote:
>> On 8/25/21 9:34 PM, olcott wrote:
>>> On 8/25/2021 8:28 PM, Richard Damon wrote:
>>
>>>> No, becuase UTM(<H^>, <H^>) Halts, thus showing that since H(<H^>,<H^>)
>>>> says non-halting it was wrong.
>>>
>>>
>>> That was your last chance.
>>
>> You admit defeat?
>>
>
> This sort of response provides substantial additional evidence that you
> never had any honest dialogue in mind.
>

What, that I give an non-answer to your non-answer. That is just a good
way to show that you aren't answering.

ANYONE looking at the group will see that you basically NEVER come up
with an error in the statement of other correcting you, but just repeat
your statement that was proven wrong. Others on the other hand present
reasoned arguements reference actual established theory, showing you are
wrong.

You just claim stuff is obvious by the meaning of the words, but you
then show that you don't even know what the real meaning of the words are.

It sounds like you have spent YEARS at this arguement, and it seems like
you haven't even gotten anyone to accept any of your basic points.

That sounds like a failed idea.

You post a crazy idea, and people point out that your don't even have
the right definitions.

On 8/25/2021 9:44 PM, Richard Damon wrote:
> On 8/25/21 10:22 PM, olcott wrote:
>> On 8/25/2021 9:04 PM, Richard Damon wrote:
>>> On 8/25/21 10:01 PM, olcott wrote:
>>>> On 8/25/2021 8:39 PM, Richard Damon wrote:
>>>>> On 8/25/21 9:34 PM, olcott wrote:
>>>>>> On 8/25/2021 8:28 PM, Richard Damon wrote:
>>>>>
>>>>>>> No, becuase UTM(<H^>, <H^>) Halts, thus showing that since
>>>>>>> H(<H^>,<H^>)
>>>>>>> says non-halting it was wrong.
>>>>>>
>>>>>>
>>>>>> That was your last chance.
>>>>>
>>>>> You admit defeat?
>>>>>
>>>>
>>>> I acknowledge that you are an incorrigible jackass.
>>>> The review process moves to phase two.
>>>>
>>>
>>> What does that mean? You going to write the paper to submit to get your
>>> rejection?
>>>
>>> You have yet to show anywhere whre my basic objections are incorrect.
>>>
>>
>> You know full well that your "objections" are pure drivel.
>
> No, I, and everyone else who is reading this will see that what I say
> makes sense.
>
> YOUR statements are the 'pure drivel'.
>
> Please note that basically no one belives your statements and everyone
> thinks you are wrong. While it is possible that you have discovered some
> hidden secret, it is very unlikely. One key thing to ask yourself, what
> grounds do I have to actually expect that I could come up with some
> insite like that that no one else beleives.
Because of this my work is not getting an honest review. It is obvious
that my work is not getting an honest review to anyone knowing the
material very well that all of the "rebuttals" simply dodge directly
assessing my points and change to subject to some other points.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 8/25/2021 9:50 PM, Richard Damon wrote:
> On 8/25/21 10:28 PM, olcott wrote:
>> On 8/25/2021 8:39 PM, Richard Damon wrote:
>>> On 8/25/21 9:34 PM, olcott wrote:
>>>> On 8/25/2021 8:28 PM, Richard Damon wrote:
>>>
>>>>> No, becuase UTM(<H^>, <H^>) Halts, thus showing that since H(<H^>,<H^>)
>>>>> says non-halting it was wrong.
>>>>
>>>>
>>>> That was your last chance.
>>>
>>> You admit defeat?
>>>
>>
>> This sort of response provides substantial additional evidence that you
>> never had any honest dialogue in mind.
>>
>
> What, that I give an non-answer to your non-answer. That is just a good
> way to show that you aren't answering.
>
> ANYONE looking at the group will see that you basically NEVER come up
> with an error in the statement of other correcting you,

Because these "corrections" simply change the subject to a different
subject.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

olcott <NoOne@NoWhere.com> writes:

> On 8/25/2021 1:55 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 8/25/2021 10:56 AM, Ben Bacarisse wrote:
>>
>>>> The halting problem is about the existence of a TM that accept those
>>>> string pairs (and only those string pairs) that encode halting
>>>> computations. All other strings are to be rejected. The halting
>>>> theorem states that no TM is a such a decider -- every TM fails to
>>>> correctly classify at least one string pair.
>>>>
>>>> You claim to have a TM, unfortunately called H, which is a halt decider.
>>>> (Yes, you sometimes deny it is a general halt decider but you keep
>>>> quoting me saying your algorithm is one, so I presume you agree that it
>>>> must be one.)
>> So you are indeed claiming to have a general halt decider! That's a
>> grand boast! (You need to say "no" if you don't want this to be taken
>> as your real position.)
>>
>>>> You tell us, again and again, that the computation of Ĥ applied to the
>>>> encoding of Ĥ (written ⟨Ĥ⟩) is a halting computation. You are quick to
>>>> jump in and say that it "only halts because... reason", but it's a
>>>> halting computation whatever the reason.
>>>> That halting computation is encoded as the string pair ⟨Ĥ⟩ ⟨Ĥ⟩. (I
>>>> prefer a notation that makes the pairing of an encoded TM and some input
>>>> explicit, but that boat sailed years ago.)
>>>> You also tell is that H rejects the string pair ⟨Ĥ⟩ ⟨Ĥ⟩. I.e. you tell
>>>> us everything we need to know to be sure that H is wrong about at least
>>>> this one halting problem instance.
>>>
>>> Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qn
>>>
>>> Until you understand that the input to Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ is not a halting
>>> computation there is no sense continuing this one way dialogue.
>> Until you understand that ⟨Ĥ1⟩ ⟨Ĥ2⟩ equals ⟨Ĥ⟩ ⟨Ĥ⟩ and that ⟨Ĥ⟩ ⟨Ĥ⟩ is a
>> string that should be accepted you are just blowing smoke.
>
> (a) While the simulating halt decider at Ĥ.qx remains in pure
> simulation mode its input ⟨Ĥ1⟩ ⟨Ĥ2⟩ never halts.

Yes, though the language is disingenuous.

> (b) Every computation that never halts while its simulating halt
> decider remains in pure simulation mode is a computation that never
> halts.

No, only computations that don't halt are halting computations. The
others, like the one encoded in the string ⟨Ĥ⟩ ⟨Ĥ⟩, are halting
computation and those strings should be accepted by a halt decider.

> Too disingenuous to continue.

Excellent! Mind you, you've said you won't talk go to me many times
before and I always end up disappointed.

--
Ben.

On 8/25/21 11:04 PM, olcott wrote:
> On 8/25/2021 9:50 PM, Richard Damon wrote:
>> On 8/25/21 10:28 PM, olcott wrote:
>>> On 8/25/2021 8:39 PM, Richard Damon wrote:
>>>> On 8/25/21 9:34 PM, olcott wrote:
>>>>> On 8/25/2021 8:28 PM, Richard Damon wrote:
>>>>
>>>>>> No, becuase UTM(<H^>, <H^>) Halts, thus showing that since
>>>>>> H(<H^>,<H^>)
>>>>>> says non-halting it was wrong.
>>>>>
>>>>>
>>>>> That was your last chance.
>>>>
>>>> You admit defeat?
>>>>
>>>
>>> This sort of response provides substantial additional evidence that you
>>> never had any honest dialogue in mind.
>>>
>>
>> What, that I give an non-answer to your non-answer. That is just a good
>> way to show that you aren't answering.
>>
>> ANYONE looking at the group will see that you basically NEVER come up
>> with an error in the statement of other correcting you,
>
> Because these "corrections" simply change the subject to a different
> subject.
>

No, the corrections show that the whole foundation of your argument are
flawed.

Maybe your problem is that you can't see what the foundation of your
arguement actually IS and that you are building on something rotten.

YOU are the one asking questions like have you stopped beating your
wife? and then you object that I, and others, point out that this
question isn't really important, because it is based on some totally
incorrect foundations.

On 8/25/21 11:03 PM, olcott wrote:
> On 8/25/2021 9:44 PM, Richard Damon wrote:
>> On 8/25/21 10:22 PM, olcott wrote:
>>> On 8/25/2021 9:04 PM, Richard Damon wrote:
>>>> On 8/25/21 10:01 PM, olcott wrote:
>>>>> On 8/25/2021 8:39 PM, Richard Damon wrote:
>>>>>> On 8/25/21 9:34 PM, olcott wrote:
>>>>>>> On 8/25/2021 8:28 PM, Richard Damon wrote:
>>>>>>
>>>>>>>> No, becuase UTM(<H^>, <H^>) Halts, thus showing that since
>>>>>>>> H(<H^>,<H^>)
>>>>>>>> says non-halting it was wrong.
>>>>>>>
>>>>>>>
>>>>>>> That was your last chance.
>>>>>>
>>>>>> You admit defeat?
>>>>>>
>>>>>
>>>>> I acknowledge that you are an incorrigible jackass.
>>>>> The review process moves to phase two.
>>>>>
>>>>
>>>> What does that mean? You going to write the paper to submit to get your
>>>> rejection?
>>>>
>>>> You have yet to show anywhere whre my basic objections are incorrect.
>>>>
>>>
>>> You know full well that your "objections" are pure drivel.
>>
>> No, I, and everyone else who is reading this will see that what I say
>> makes sense.
>>
>> YOUR statements are the 'pure drivel'.
>>
>> Please note that basically no one belives your statements and everyone
>> thinks you are wrong. While it is possible that you have discovered some
>> hidden secret, it is very unlikely. One key thing to ask yourself, what
>> grounds do I have to actually expect that I could come up with some
>> insite like that that no one else beleives.
> Because of this my work is not getting an honest review. It is obvious
> that my work is not getting an honest review to anyone knowing the
> material very well that all of the "rebuttals" simply dodge directly
> assessing my points and change to subject to some other points.
>

No, it HAS gotten an Honest review, and you just don't want to accept
it, because it shows how BAD your logic is.

Since YOU have shown that you don't understand even the basics of the
material you are working on.

YOU are the one specializing in diversions, and don't deal with the
fundamentals.

Things like, the definition of Halting is based on the behavior of the
ACTUAL machine. Aborted simulations don't actually prove anything.

Things like that a Computation will ALWAYS give the same answer for a
gien input, BY DEFINITION. If it doesn't, it isn't a Computation. PERIOD.

You make nonsense claims about arcs on Turing Machine Diagrams that just
don't exist. (Like back from H^.qx to H^.q0, maybe you now understand
that, but I am not sure).

On 8/25/21 11:10 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:

>> Too disingenuous to continue.
>
> Excellent! Mind you, you've said you won't talk go to me many times
> before and I always end up disappointed.
>

Yes, me too. It is clear that when people clearly point out his
mistakes, his brain starts to go crazy and he finds it irresistible to
lash out and try to muddy the air with some illogic to try and hide the
clear rebuttal.

I think he hopes that the thread will go off some other direction and
the clear rebuttal will be forgotten.

THAT is why he calls them 'dishonest dodges', he thinks if he says that
enough some people might beleive it and not look at them.

olcott <NoOne@NoWhere.com> writes:

> When we define Ĵ to be exactly like Ĥ except that it has a UTM at Ĵ.qx
> instead of a simulating halt decider then we can see that Ĵ applied to
> ⟨Ĵ⟩ never halts.
>
> Ĵ copies its input ⟨Ĵ1⟩ to ⟨Ĵ2⟩ then simulates this input Ĵ1 with its input ⟨Ĵ2⟩
> which copies its input ⟨Ĵ2⟩ to ⟨Ĵ3⟩ then simulates this input Ĵ2 with
> its input ⟨Ĵ3⟩
> which copies its input ⟨Ĵ3⟩ to ⟨Ĵ4⟩ then simulates this input Ĵ3 with
> its input ⟨Ĵ4⟩ ...

Again, no. The computation is indeed non halting, but this is not
literally how it unfolds. This is a metaphorical description of the
execution, not a literal on. Only the first copy is a literal coping of
a string on the tape.

> With the Peter Linz Ĥ we have exactly the same thing while the
> simulating halt decider at Ĥ.qx remains in simulation mode.

Peter Linz's H does not exist. Yours does (and is wrong) but his does
not.

--
Ben.

Richard Damon <Richard@Damon-Family.org> writes:

> On 8/25/21 11:10 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>
>>> Too disingenuous to continue.
>>
>> Excellent! Mind you, you've said you won't talk go to me many times
>> before and I always end up disappointed.
>
> Yes, me too. It is clear that when people clearly point out his
> mistakes, his brain starts to go crazy and he finds it irresistible to
> lash out and try to muddy the air with some illogic to try and hide the
> clear rebuttal.

He'll keep replying, I'm sure. The only way the madness can end is if
we stop replying. It's not as if any casual reader can be in any doubt
that he's wrong. He'll taunt and hurl abuse, but that is a mark of
respect coming from PO.

--
Ben.