void D(void (*x)())
{ int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return;
}

int main()
{ D(D);
H(D, D);
}

The fact that no D(D) ever stops running unless H(D,D) aborts the
simlation of its input conclusively proves that the input to H(D,D)
specifies a non-halting sequence of configurations.

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

On 11/28/22 12:56 PM, olcott wrote:
> void D(void (*x)())
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return;
> }
>
> int main()
> {
>   D(D);
>   H(D, D);
> }
>
> The fact that no D(D) ever stops running unless H(D,D) aborts the
> simlation of its input conclusively proves that the input to H(D,D)
> specifies a non-halting sequence of configurations.
>

No, THIS D(D) will Halt even if THIS copy of H doesn't abort it.

(There is EXACTLY ONE D and ONE H presentd at a time).

It will halt because the copy of H that it calls WILL abort is
simulation of the copy of the input it is given. Those are different
copies of the supposed program H, and have the exact code that you
define the H that gives the answer to have.

Note, to SHOW that "Unless" you need to change JUST the outer H that
main calls, without changing the H that D calls, as that is what that
word mean in this context.

Otherwise you are just the despicable liar for talking about the
behavior of a "non-input", as the input D needs to remain calling the H
that it was defined to call, which is the H that returns the answer.

Your problem is that you have entangled two independent programs to the
point that they are no longer independent.

It is not possible to create an INDEPENDENT program H that you give as
an input an INDEPENDET program D for it to decide on.

Neither your subroutine H or subroutine D end up being actual
"Computations" or "Algiortiths applied to an input" per the definitions
of Computation Theory, so neither of them end up being independently the
equivalent of a Turing Machine.

That is why you fail. You just don't understand the basics of the problem.

You are just proving your ignorance of the material. The fact that you
try to bring in "Sets" when there are none in the problem just shows this.

On 11/28/2022 11:56 AM, olcott wrote:
> void D(void (*x)())
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return;
> }
>
> int main()
> {
>   D(D);
>   H(D, D);
> }
>
> The fact that no D(D) ever stops running unless H(D,D) aborts the
> simlation of its input conclusively proves that the input to H(D,D)
> specifies a non-halting sequence of configurations.
>

[Ignoring stack overflow]

The above D(D) never stops running unless the H(D,D) that it invokes
aborts the simulation of its input.

D(D) correctly simulated by the above H(D,D) never stops running unless
aborted.

Thus no D(D) ever stops running unless an H(D,D) aborts the simulation
of its input.

This conclusively proves that the input to H(D,D) specifies a
non-halting sequence of configurations.

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

On 11/29/22 11:35 AM, olcott wrote:
> On 11/28/2022 11:56 AM, olcott wrote:
>> void D(void (*x)())
>> {
>>    int Halt_Status = H(x, x);
>>    if (Halt_Status)
>>      HERE: goto HERE;
>>    return;
>> }
>>
>> int main()
>> {
>>    D(D);
>>    H(D, D);
>> }
>>
>> The fact that no D(D) ever stops running unless H(D,D) aborts the
>> simlation of its input conclusively proves that the input to H(D,D)
>> specifies a non-halting sequence of configurations.
>>
>
> [Ignoring stack overflow]
>
> The above D(D) never stops running unless the H(D,D) that it invokes
> aborts the simulation of its input.

Right, but that is ok, and doesn't make that D non-halting by the
DEFINITION of what a Halt Decider needs to ddcide.

H(M,x) needs to return Halting if M(x) Halts.

Since D(D) halts, this means that H(D,D) needs to return Halting.

Nothing in that ask anything about D using a simulation that happens to
be aborted.

You are just using wrong definitions.

>
> D(D) correctly simulated by the above H(D,D) never stops running unless
> aborted.

Nope, UTM(D,D) which is the DEFINITION of a "Correct Simulation" will
Halt. Thus the "Correct Simulation" of this input WILL HALT.

The H you have provided never does a correct wsimulation, so what it
does is actually irrelevent.

>
> Thus no D(D) ever stops running unless an H(D,D) aborts the simulation
> of its input.

Nope, since the H(D,D) that D calls DOES abort its simulation, the
H(D,D) simulating this D didn't actually NEED to abort its simulation,
as the UTM simulation shows, so it did so incorrectly.

You can't use "unless" to ask about something that is fixed in the
input, only about THIS instance of H.

You just don't understand what "input" or "Turing Machine" mean.

>
> This conclusively proves that the input to H(D,D) specifies a
> non-halting sequence of configurations.
>
>

Nope, it proves you don't understand the meaning of the words you are
using, and that you aren't actually working on the halting problem due
to that error.

Thus you have wasted the last 18 year of your life (or is it 19 yet)
because you made yourself INTENTIONALLY IGNORANT of what you actually
needed to know to do the problem.

On 11/29/2022 5:47 PM, Richard Damon wrote:
> On 11/29/22 11:35 AM, olcott wrote:
>> On 11/28/2022 11:56 AM, olcott wrote:
>>> void D(void (*x)())
>>> {
>>>    int Halt_Status = H(x, x);
>>>    if (Halt_Status)
>>>      HERE: goto HERE;
>>>    return;
>>> }
>>>
>>> int main()
>>> {
>>>    D(D);
>>>    H(D, D);
>>> }
>>>
>>> The fact that no D(D) ever stops running unless H(D,D) aborts the
>>> simlation of its input conclusively proves that the input to H(D,D)
>>> specifies a non-halting sequence of configurations.
>>>
>>
>> [Ignoring stack overflow]
>>
>> The above D(D) never stops running unless the H(D,D) that it invokes
>> aborts the simulation of its input.
>
> Right, but that is ok, and doesn't make that D non-halting by the
> DEFINITION of what a Halt Decider needs to ddcide.
>
> H(M,x) needs to return Halting if M(x) Halts.
>
> Since D(D) halts, this means that H(D,D) needs to return Halting.
>
> Nothing in that ask anything about D using a simulation that happens to
> be aborted.
>
> You are just using wrong definitions.
>
>>
>> D(D) correctly simulated by the above H(D,D) never stops running
>> unless aborted.
>
> Nope, UTM(D,D) which is the DEFINITION of a "Correct Simulation" will
> Halt. Thus the "Correct Simulation" of this input WILL HALT.
>
> The H you have provided never does a correct wsimulation, so what it
> does is actually irrelevent.
>
>>
>> Thus no D(D) ever stops running unless an H(D,D) aborts the simulation
>> of its input.
>
> Nope, since the H(D,D) that D calls DOES abort its simulation, the
> H(D,D) simulating this D didn't actually NEED to abort its simulation,

You are not paying close enough attention to the exact words that I just
said.

If No H(D,D) in the universe ever stops simulating its input then no
corresponding executed or simulated D(D) in the universe ever stops
running.

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

On 11/29/22 7:52 PM, olcott wrote:
> On 11/29/2022 5:47 PM, Richard Damon wrote:
>> On 11/29/22 11:35 AM, olcott wrote:
>>> On 11/28/2022 11:56 AM, olcott wrote:
>>>> void D(void (*x)())
>>>> {
>>>>    int Halt_Status = H(x, x);
>>>>    if (Halt_Status)
>>>>      HERE: goto HERE;
>>>>    return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>>    D(D);
>>>>    H(D, D);
>>>> }
>>>>
>>>> The fact that no D(D) ever stops running unless H(D,D) aborts the
>>>> simlation of its input conclusively proves that the input to H(D,D)
>>>> specifies a non-halting sequence of configurations.
>>>>
>>>
>>> [Ignoring stack overflow]
>>>
>>> The above D(D) never stops running unless the H(D,D) that it invokes
>>> aborts the simulation of its input.
>>
>> Right, but that is ok, and doesn't make that D non-halting by the
>> DEFINITION of what a Halt Decider needs to ddcide.
>>
>> H(M,x) needs to return Halting if M(x) Halts.
>>
>> Since D(D) halts, this means that H(D,D) needs to return Halting.
>>
>> Nothing in that ask anything about D using a simulation that happens
>> to be aborted.
>>
>> You are just using wrong definitions.
>>
>>>
>>> D(D) correctly simulated by the above H(D,D) never stops running
>>> unless aborted.
>>
>> Nope, UTM(D,D) which is the DEFINITION of a "Correct Simulation" will
>> Halt. Thus the "Correct Simulation" of this input WILL HALT.
>>
>> The H you have provided never does a correct wsimulation, so what it
>> does is actually irrelevent.
>>
>>>
>>> Thus no D(D) ever stops running unless an H(D,D) aborts the
>>> simulation of its input.
>>
>> Nope, since the H(D,D) that D calls DOES abort its simulation, the
>> H(D,D) simulating this D didn't actually NEED to abort its simulation,
>
> You are not paying close enough attention to the exact words that I just
> said.
>
> If No H(D,D) in the universe ever stops simulating its input then no
> corresponding executed or simulated D(D) in the universe ever stops
> running.
>
>
>

So, you are just PROVING that you are not working on the Halting
Problem, because that isn't the Halting Problem criteria.

The Halting Problem is that H(M,x) must return Halting if M(x) Halts and
Non-Halting if M(x) will NEVER halt even after an unbounded number of steps.

D(D) Does Halt if the H it is built on returns Non-Halting for H(D,D),
so that answer can NOT be correct. PERIOD.

The fact that you can not construct any H by your template that can
simulate the D built on it to a final state is NOT a restatement of that
statement. YOU FAIL.

That, or you are just stating the fact that you can't actually build a
Halting Decider that can correctly answer for H(D,D) for the D built
from it per the Linz template.

You are also proving that you are ignorant of what these things are
actually about, because you keep on LYING by insisting that you are
working on it.

You are shown to be DECEPTIVE, as you keep on adding and removing the
"by H".

Note, we don't care about "Any" H(D,D), we care about the SPEICIFIC
H(D,D) that is claimed to get the right answer about the D built on IT.

Note, that for THAT H, the way you have currently defined it, then the
correctly simulated or executed D(D) does Halt. You just get confuse
because that H doesn't do a correct simuation, so you look at a
DIFFERENT H and a DIFFERENT D where H does a correct simulaition, but of
the WRONG D, and shows the correct answer for that OTHER D, but never
gives it, so it fails.

Your confusion just proves that you don't understand what a Turing
Machine actually is, or what a Program actually is, or how computers
actually work.

You are just showing the word how bad you grasp of logic is, and how
little you understand. You have destroyed what little reputation you
might have had by your instance on things that aren't actually what you
are trying to claim about.

On 11/29/2022 7:48 PM, Richard Damon wrote:
> On 11/29/22 7:52 PM, olcott wrote:
>> On 11/29/2022 5:47 PM, Richard Damon wrote:
>>> On 11/29/22 11:35 AM, olcott wrote:
>>>> On 11/28/2022 11:56 AM, olcott wrote:
>>>>> void D(void (*x)())
>>>>> {
>>>>>    int Halt_Status = H(x, x);
>>>>>    if (Halt_Status)
>>>>>      HERE: goto HERE;
>>>>>    return;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>>    D(D);
>>>>>    H(D, D);
>>>>> }
>>>>>
>>>>> The fact that no D(D) ever stops running unless H(D,D) aborts the
>>>>> simlation of its input conclusively proves that the input to H(D,D)
>>>>> specifies a non-halting sequence of configurations.
>>>>>
>>>>
>>>> [Ignoring stack overflow]
>>>>
>>>> The above D(D) never stops running unless the H(D,D) that it invokes
>>>> aborts the simulation of its input.
>>>
>>> Right, but that is ok, and doesn't make that D non-halting by the
>>> DEFINITION of what a Halt Decider needs to ddcide.
>>>
>>> H(M,x) needs to return Halting if M(x) Halts.
>>>
>>> Since D(D) halts, this means that H(D,D) needs to return Halting.
>>>
>>> Nothing in that ask anything about D using a simulation that happens
>>> to be aborted.
>>>
>>> You are just using wrong definitions.
>>>
>>>>
>>>> D(D) correctly simulated by the above H(D,D) never stops running
>>>> unless aborted.
>>>
>>> Nope, UTM(D,D) which is the DEFINITION of a "Correct Simulation" will
>>> Halt. Thus the "Correct Simulation" of this input WILL HALT.
>>>
>>> The H you have provided never does a correct wsimulation, so what it
>>> does is actually irrelevent.
>>>
>>>>
>>>> Thus no D(D) ever stops running unless an H(D,D) aborts the
>>>> simulation of its input.
>>>
>>> Nope, since the H(D,D) that D calls DOES abort its simulation, the
>>> H(D,D) simulating this D didn't actually NEED to abort its simulation,
>>
>> You are not paying close enough attention to the exact words that I
>> just said.
>>
>> If No H(D,D) in the universe ever stops simulating its input then no
>> corresponding executed or simulated D(D) in the universe ever stops
>> running.
>>
>>
>>
>
> So, you are just PROVING that you are not working on the Halting
> Problem, because that isn't the Halting Problem criteria.
>

I have already shown that people having a much deeper understanding than
the mere rote memorization of textbooks understand that my adaptation of
the halt status criteria is equivalent to the conventional notions.

--
Copyright 2022 Olcott

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

On 11/29/22 9:30 PM, olcott wrote:
> On 11/29/2022 7:48 PM, Richard Damon wrote:
>> On 11/29/22 7:52 PM, olcott wrote:
>>> On 11/29/2022 5:47 PM, Richard Damon wrote:
>>>> On 11/29/22 11:35 AM, olcott wrote:
>>>>> On 11/28/2022 11:56 AM, olcott wrote:
>>>>>> void D(void (*x)())
>>>>>> {
>>>>>>    int Halt_Status = H(x, x);
>>>>>>    if (Halt_Status)
>>>>>>      HERE: goto HERE;
>>>>>>    return;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>>    D(D);
>>>>>>    H(D, D);
>>>>>> }
>>>>>>
>>>>>> The fact that no D(D) ever stops running unless H(D,D) aborts the
>>>>>> simlation of its input conclusively proves that the input to
>>>>>> H(D,D) specifies a non-halting sequence of configurations.
>>>>>>
>>>>>
>>>>> [Ignoring stack overflow]
>>>>>
>>>>> The above D(D) never stops running unless the H(D,D) that it
>>>>> invokes aborts the simulation of its input.
>>>>
>>>> Right, but that is ok, and doesn't make that D non-halting by the
>>>> DEFINITION of what a Halt Decider needs to ddcide.
>>>>
>>>> H(M,x) needs to return Halting if M(x) Halts.
>>>>
>>>> Since D(D) halts, this means that H(D,D) needs to return Halting.
>>>>
>>>> Nothing in that ask anything about D using a simulation that happens
>>>> to be aborted.
>>>>
>>>> You are just using wrong definitions.
>>>>
>>>>>
>>>>> D(D) correctly simulated by the above H(D,D) never stops running
>>>>> unless aborted.
>>>>
>>>> Nope, UTM(D,D) which is the DEFINITION of a "Correct Simulation"
>>>> will Halt. Thus the "Correct Simulation" of this input WILL HALT.
>>>>
>>>> The H you have provided never does a correct wsimulation, so what it
>>>> does is actually irrelevent.
>>>>
>>>>>
>>>>> Thus no D(D) ever stops running unless an H(D,D) aborts the
>>>>> simulation of its input.
>>>>
>>>> Nope, since the H(D,D) that D calls DOES abort its simulation, the
>>>> H(D,D) simulating this D didn't actually NEED to abort its simulation,
>>>
>>> You are not paying close enough attention to the exact words that I
>>> just said.
>>>
>>> If No H(D,D) in the universe ever stops simulating its input then no
>>> corresponding executed or simulated D(D) in the universe ever stops
>>> running.
>>>
>>>
>>>
>>
>> So, you are just PROVING that you are not working on the Halting
>> Problem, because that isn't the Halting Problem criteria.
>>
>
> I have already shown that people having a much deeper understanding than
> the mere rote memorization of textbooks understand that my adaptation of
> the halt status criteria is equivalent to the conventional notions.
>
>

Nope. You are perhaps DECEIVED them into giving assent to a statement
whixh appears to match the actual definition but doesn't with your
unusual meaning of the words.

Note, your CLAIM they are actually eqivalent means you thing that D(D)
Halting means it is correct to say it is non-halting.

That shows that YOUR logic system has gone inconsistent and is TOTALLLY
WORTHLESS.

Your failure to understand that means you are totally ignorant of how
logic works or are just a pahtological liar.

You failure to see this just proves your stupidity.

You claim of "Equivalence" is EXACTLY like saying 1 == 2 or True == FALSE.

You have failed but seem to be too stupid to understand it.

On 11/29/2022 8:54 PM, Richard Damon wrote:
> On 11/29/22 9:30 PM, olcott wrote:
>> On 11/29/2022 7:48 PM, Richard Damon wrote:
>>> On 11/29/22 7:52 PM, olcott wrote:
>>>> On 11/29/2022 5:47 PM, Richard Damon wrote:
>>>>> On 11/29/22 11:35 AM, olcott wrote:
>>>>>> On 11/28/2022 11:56 AM, olcott wrote:
>>>>>>> void D(void (*x)())
>>>>>>> {
>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>    if (Halt_Status)
>>>>>>>      HERE: goto HERE;
>>>>>>>    return;
>>>>>>> }
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>>    D(D);
>>>>>>>    H(D, D);
>>>>>>> }
>>>>>>>
>>>>>>> The fact that no D(D) ever stops running unless H(D,D) aborts the
>>>>>>> simlation of its input conclusively proves that the input to
>>>>>>> H(D,D) specifies a non-halting sequence of configurations.
>>>>>>>
>>>>>>
>>>>>> [Ignoring stack overflow]
>>>>>>
>>>>>> The above D(D) never stops running unless the H(D,D) that it
>>>>>> invokes aborts the simulation of its input.
>>>>>
>>>>> Right, but that is ok, and doesn't make that D non-halting by the
>>>>> DEFINITION of what a Halt Decider needs to ddcide.
>>>>>
>>>>> H(M,x) needs to return Halting if M(x) Halts.
>>>>>
>>>>> Since D(D) halts, this means that H(D,D) needs to return Halting.
>>>>>
>>>>> Nothing in that ask anything about D using a simulation that
>>>>> happens to be aborted.
>>>>>
>>>>> You are just using wrong definitions.
>>>>>
>>>>>>
>>>>>> D(D) correctly simulated by the above H(D,D) never stops running
>>>>>> unless aborted.
>>>>>
>>>>> Nope, UTM(D,D) which is the DEFINITION of a "Correct Simulation"
>>>>> will Halt. Thus the "Correct Simulation" of this input WILL HALT.
>>>>>
>>>>> The H you have provided never does a correct wsimulation, so what
>>>>> it does is actually irrelevent.
>>>>>
>>>>>>
>>>>>> Thus no D(D) ever stops running unless an H(D,D) aborts the
>>>>>> simulation of its input.
>>>>>
>>>>> Nope, since the H(D,D) that D calls DOES abort its simulation, the
>>>>> H(D,D) simulating this D didn't actually NEED to abort its simulation,
>>>>
>>>> You are not paying close enough attention to the exact words that I
>>>> just said.
>>>>
>>>> If No H(D,D) in the universe ever stops simulating its input then no
>>>> corresponding executed or simulated D(D) in the universe ever stops
>>>> running.
>>>>
>>>>
>>>>
>>>
>>> So, you are just PROVING that you are not working on the Halting
>>> Problem, because that isn't the Halting Problem criteria.
>>>
>>
>> I have already shown that people having a much deeper understanding
>> than the mere rote memorization of textbooks understand that my
>> adaptation of the halt status criteria is equivalent to the
>> conventional notions.
>>
>>
>
> Nope. You are perhaps DECEIVED them into giving assent to a statement
> whixh appears to match the actual definition but doesn't with your
> unusual meaning of the words.
>

He has written a textbook on the subject and many many papers,
It is ridiculous to believe that:
(a) He could be fooled into agreeing with a statement that he
did not fully understand.
AND
(b) Give me permission to quote his agreement with this statement.

I do not believe that Ben believed that he was fooled when Ben made the
claim that he was fooled. Ben knows better than this. Ben simply ran out
of options for rebuttal and thus grasped at straws.

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

On 11/29/22 10:29 PM, olcott wrote:
> On 11/29/2022 8:54 PM, Richard Damon wrote:
>> On 11/29/22 9:30 PM, olcott wrote:
>>> On 11/29/2022 7:48 PM, Richard Damon wrote:
>>>> On 11/29/22 7:52 PM, olcott wrote:
>>>>> On 11/29/2022 5:47 PM, Richard Damon wrote:
>>>>>> On 11/29/22 11:35 AM, olcott wrote:
>>>>>>> On 11/28/2022 11:56 AM, olcott wrote:
>>>>>>>> void D(void (*x)())
>>>>>>>> {
>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>    if (Halt_Status)
>>>>>>>>      HERE: goto HERE;
>>>>>>>>    return;
>>>>>>>> }
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>>    D(D);
>>>>>>>>    H(D, D);
>>>>>>>> }
>>>>>>>>
>>>>>>>> The fact that no D(D) ever stops running unless H(D,D) aborts
>>>>>>>> the simlation of its input conclusively proves that the input to
>>>>>>>> H(D,D) specifies a non-halting sequence of configurations.
>>>>>>>>
>>>>>>>
>>>>>>> [Ignoring stack overflow]
>>>>>>>
>>>>>>> The above D(D) never stops running unless the H(D,D) that it
>>>>>>> invokes aborts the simulation of its input.
>>>>>>
>>>>>> Right, but that is ok, and doesn't make that D non-halting by the
>>>>>> DEFINITION of what a Halt Decider needs to ddcide.
>>>>>>
>>>>>> H(M,x) needs to return Halting if M(x) Halts.
>>>>>>
>>>>>> Since D(D) halts, this means that H(D,D) needs to return Halting.
>>>>>>
>>>>>> Nothing in that ask anything about D using a simulation that
>>>>>> happens to be aborted.
>>>>>>
>>>>>> You are just using wrong definitions.
>>>>>>
>>>>>>>
>>>>>>> D(D) correctly simulated by the above H(D,D) never stops running
>>>>>>> unless aborted.
>>>>>>
>>>>>> Nope, UTM(D,D) which is the DEFINITION of a "Correct Simulation"
>>>>>> will Halt. Thus the "Correct Simulation" of this input WILL HALT.
>>>>>>
>>>>>> The H you have provided never does a correct wsimulation, so what
>>>>>> it does is actually irrelevent.
>>>>>>
>>>>>>>
>>>>>>> Thus no D(D) ever stops running unless an H(D,D) aborts the
>>>>>>> simulation of its input.
>>>>>>
>>>>>> Nope, since the H(D,D) that D calls DOES abort its simulation, the
>>>>>> H(D,D) simulating this D didn't actually NEED to abort its
>>>>>> simulation,
>>>>>
>>>>> You are not paying close enough attention to the exact words that I
>>>>> just said.
>>>>>
>>>>> If No H(D,D) in the universe ever stops simulating its input then
>>>>> no corresponding executed or simulated D(D) in the universe ever
>>>>> stops running.
>>>>>
>>>>>
>>>>>
>>>>
>>>> So, you are just PROVING that you are not working on the Halting
>>>> Problem, because that isn't the Halting Problem criteria.
>>>>
>>>
>>> I have already shown that people having a much deeper understanding
>>> than the mere rote memorization of textbooks understand that my
>>> adaptation of the halt status criteria is equivalent to the
>>> conventional notions.
>>>
>>>
>>
>> Nope. You are perhaps DECEIVED them into giving assent to a statement
>> whixh appears to match the actual definition but doesn't with your
>> unusual meaning of the words.
>>
>
> He has written a textbook on the subject and many many papers,
> It is ridiculous to believe that:
> (a) He could be fooled into agreeing with a statement that he
>     did not fully understand.
> AND
> (b) Give me permission to quote his agreement with this statement.
>
> I do not believe that Ben believed that he was fooled when Ben made the
> claim that he was fooled. Ben knows better than this. Ben simply ran out
> of options for rebuttal and thus grasped at straws.
>
>

Right, and he agreed that if H shows that the CORRECT SIMULATION of its
input is non-halting, which is the simulation by a UTM. H only does a
correct simulaition if its simulation agrees with THAT simulation.

Since UTM(D,D) will halt if H(D,D) returns 0, your H can NOT "correctly
determine" that ANY correct simulation, let alone its own, would not
reach a final state, so you don't have a basis to make your claim of
correctly determine.

YOU make the INCORRECGT leap from "Correct Simulation" (which to someone
in the field implies COMPLETE, ala the simulation of an actual UTM) to a
PARTIAL simulation that H does.

When you interprete the statement you gave with the understanding that
"Correct Simulation" will be taken to mean the exact simulation of a
UTM, you can see what he was agreeing to.

Remember, you SPECIFICALLY have pointed out that was the exact and
complete statement he was agreeing to, it did NOT include your perverse
logic that tries to justify that a PARTIAL simulation by H not reaching
an end state is also sufficient to show non-halting, because that just
doesn't fit the ACTUAL definition of the words as used in the field.

Correct doesn't mean correct as far as it goes, it means correct and
going to the end.

WRONG DEFINITION -> WRONG CONCLUSIONS.

YOU FAIL.

On 11/29/2022 10:03 PM, Richard Damon wrote:
> On 11/29/22 10:29 PM, olcott wrote:
>> On 11/29/2022 8:54 PM, Richard Damon wrote:
>>> On 11/29/22 9:30 PM, olcott wrote:
>>>> On 11/29/2022 7:48 PM, Richard Damon wrote:
>>>>> On 11/29/22 7:52 PM, olcott wrote:
>>>>>> On 11/29/2022 5:47 PM, Richard Damon wrote:
>>>>>>> On 11/29/22 11:35 AM, olcott wrote:
>>>>>>>> On 11/28/2022 11:56 AM, olcott wrote:
>>>>>>>>> void D(void (*x)())
>>>>>>>>> {
>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>    if (Halt_Status)
>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>    return;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>>    D(D);
>>>>>>>>>    H(D, D);
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> The fact that no D(D) ever stops running unless H(D,D) aborts
>>>>>>>>> the simlation of its input conclusively proves that the input
>>>>>>>>> to H(D,D) specifies a non-halting sequence of configurations.
>>>>>>>>>
>>>>>>>>
>>>>>>>> [Ignoring stack overflow]
>>>>>>>>
>>>>>>>> The above D(D) never stops running unless the H(D,D) that it
>>>>>>>> invokes aborts the simulation of its input.
>>>>>>>
>>>>>>> Right, but that is ok, and doesn't make that D non-halting by the
>>>>>>> DEFINITION of what a Halt Decider needs to ddcide.
>>>>>>>
>>>>>>> H(M,x) needs to return Halting if M(x) Halts.
>>>>>>>
>>>>>>> Since D(D) halts, this means that H(D,D) needs to return Halting.
>>>>>>>
>>>>>>> Nothing in that ask anything about D using a simulation that
>>>>>>> happens to be aborted.
>>>>>>>
>>>>>>> You are just using wrong definitions.
>>>>>>>
>>>>>>>>
>>>>>>>> D(D) correctly simulated by the above H(D,D) never stops running
>>>>>>>> unless aborted.
>>>>>>>
>>>>>>> Nope, UTM(D,D) which is the DEFINITION of a "Correct Simulation"
>>>>>>> will Halt. Thus the "Correct Simulation" of this input WILL HALT.
>>>>>>>
>>>>>>> The H you have provided never does a correct wsimulation, so what
>>>>>>> it does is actually irrelevent.
>>>>>>>
>>>>>>>>
>>>>>>>> Thus no D(D) ever stops running unless an H(D,D) aborts the
>>>>>>>> simulation of its input.
>>>>>>>
>>>>>>> Nope, since the H(D,D) that D calls DOES abort its simulation,
>>>>>>> the H(D,D) simulating this D didn't actually NEED to abort its
>>>>>>> simulation,
>>>>>>
>>>>>> You are not paying close enough attention to the exact words that
>>>>>> I just said.
>>>>>>
>>>>>> If No H(D,D) in the universe ever stops simulating its input then
>>>>>> no corresponding executed or simulated D(D) in the universe ever
>>>>>> stops running.
>>>>>>
>>>>>>
>>>>>>
>>>>>
>>>>> So, you are just PROVING that you are not working on the Halting
>>>>> Problem, because that isn't the Halting Problem criteria.
>>>>>
>>>>
>>>> I have already shown that people having a much deeper understanding
>>>> than the mere rote memorization of textbooks understand that my
>>>> adaptation of the halt status criteria is equivalent to the
>>>> conventional notions.
>>>>
>>>>
>>>
>>> Nope. You are perhaps DECEIVED them into giving assent to a statement
>>> whixh appears to match the actual definition but doesn't with your
>>> unusual meaning of the words.
>>>
>>
>> He has written a textbook on the subject and many many papers,
>> It is ridiculous to believe that:
>> (a) He could be fooled into agreeing with a statement that he
>>      did not fully understand.
>> AND
>> (b) Give me permission to quote his agreement with this statement.
>>
>> I do not believe that Ben believed that he was fooled when Ben made
>> the claim that he was fooled. Ben knows better than this. Ben simply
>> ran out of options for rebuttal and thus grasped at straws.
>>
>>
>
> Right, and he agreed that if H shows that the CORRECT SIMULATION of its
> input is non-halting, which is the simulation by a UTM. H only does a
> correct simulaition if its simulation agrees with THAT simulation.
>

I am only willing to have a mutually honest dialogue.

When I prove that you are incorrect on a point you never acknowledge
that I proved that you are incorrect you simply change the subject.

Acknowledge that he was not fooled and that he most likely fully
understood what he agreed to or we cannot move on to the next point.

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

On 11/29/22 11:38 PM, olcott wrote:
> On 11/29/2022 10:03 PM, Richard Damon wrote:
>> On 11/29/22 10:29 PM, olcott wrote:
>>> On 11/29/2022 8:54 PM, Richard Damon wrote:
>>>> On 11/29/22 9:30 PM, olcott wrote:
>>>>> On 11/29/2022 7:48 PM, Richard Damon wrote:
>>>>>> On 11/29/22 7:52 PM, olcott wrote:
>>>>>>> On 11/29/2022 5:47 PM, Richard Damon wrote:
>>>>>>>> On 11/29/22 11:35 AM, olcott wrote:
>>>>>>>>> On 11/28/2022 11:56 AM, olcott wrote:
>>>>>>>>>> void D(void (*x)())
>>>>>>>>>> {
>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>    return;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> int main()
>>>>>>>>>> {
>>>>>>>>>>    D(D);
>>>>>>>>>>    H(D, D);
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> The fact that no D(D) ever stops running unless H(D,D) aborts
>>>>>>>>>> the simlation of its input conclusively proves that the input
>>>>>>>>>> to H(D,D) specifies a non-halting sequence of configurations.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> [Ignoring stack overflow]
>>>>>>>>>
>>>>>>>>> The above D(D) never stops running unless the H(D,D) that it
>>>>>>>>> invokes aborts the simulation of its input.
>>>>>>>>
>>>>>>>> Right, but that is ok, and doesn't make that D non-halting by
>>>>>>>> the DEFINITION of what a Halt Decider needs to ddcide.
>>>>>>>>
>>>>>>>> H(M,x) needs to return Halting if M(x) Halts.
>>>>>>>>
>>>>>>>> Since D(D) halts, this means that H(D,D) needs to return Halting.
>>>>>>>>
>>>>>>>> Nothing in that ask anything about D using a simulation that
>>>>>>>> happens to be aborted.
>>>>>>>>
>>>>>>>> You are just using wrong definitions.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> D(D) correctly simulated by the above H(D,D) never stops
>>>>>>>>> running unless aborted.
>>>>>>>>
>>>>>>>> Nope, UTM(D,D) which is the DEFINITION of a "Correct Simulation"
>>>>>>>> will Halt. Thus the "Correct Simulation" of this input WILL HALT.
>>>>>>>>
>>>>>>>> The H you have provided never does a correct wsimulation, so
>>>>>>>> what it does is actually irrelevent.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> Thus no D(D) ever stops running unless an H(D,D) aborts the
>>>>>>>>> simulation of its input.
>>>>>>>>
>>>>>>>> Nope, since the H(D,D) that D calls DOES abort its simulation,
>>>>>>>> the H(D,D) simulating this D didn't actually NEED to abort its
>>>>>>>> simulation,
>>>>>>>
>>>>>>> You are not paying close enough attention to the exact words that
>>>>>>> I just said.
>>>>>>>
>>>>>>> If No H(D,D) in the universe ever stops simulating its input then
>>>>>>> no corresponding executed or simulated D(D) in the universe ever
>>>>>>> stops running.
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> So, you are just PROVING that you are not working on the Halting
>>>>>> Problem, because that isn't the Halting Problem criteria.
>>>>>>
>>>>>
>>>>> I have already shown that people having a much deeper understanding
>>>>> than the mere rote memorization of textbooks understand that my
>>>>> adaptation of the halt status criteria is equivalent to the
>>>>> conventional notions.
>>>>>
>>>>>
>>>>
>>>> Nope. You are perhaps DECEIVED them into giving assent to a
>>>> statement whixh appears to match the actual definition but doesn't
>>>> with your unusual meaning of the words.
>>>>
>>>
>>> He has written a textbook on the subject and many many papers,
>>> It is ridiculous to believe that:
>>> (a) He could be fooled into agreeing with a statement that he
>>>      did not fully understand.
>>> AND
>>> (b) Give me permission to quote his agreement with this statement.
>>>
>>> I do not believe that Ben believed that he was fooled when Ben made
>>> the claim that he was fooled. Ben knows better than this. Ben simply
>>> ran out of options for rebuttal and thus grasped at straws.
>>>
>>>
>>
>> Right, and he agreed that if H shows that the CORRECT SIMULATION of
>> its input is non-halting, which is the simulation by a UTM. H only
>> does a correct simulaition if its simulation agrees with THAT simulation.
>>
>
> I am only willing to have a mutually honest dialogue.
>

I'm AM being Honest.

> When I prove that you are incorrect on a point you never acknowledge
> that I proved that you are incorrect you simply change the subject.

Except that you never have proven me wrong on any major point.

>
> Acknowledge that he was not fooled and that he most likely fully
> understood what he agreed to or we cannot move on to the next point.
>

"Fooled" may be a stronger word then needed. He does not interpret the
words the way you do. This is in part due to your enforced IGNORANCE of
the subject.

As I said, to HIM, "CORRECT SIMULATION" means a COMPLETE SIMULATION,
like a UTM, that WILL match the behavior of the direct exectution of
that input.

Since D(D) will Halt since H(D,D) returns 0, any "Correct Simulation" of
the input to H(D,D) will be Halting.

Thus, IF H can correctly determine that its correct simulation of the
input would never halt can only be true if the direct exectution of THAT
input, exactly as it is, would not halt. Not the input built on a
DIFFERENT H that actually DOES a correct simulation, but THIS input,
built on the H that DOES abott its simulation and return 0.

You are just showing that you don't know the meaning of the basic words,
and thus incorrectly, and deceptively (at least to yourself) twist the
meaning so you don't really understand what they mean to people how
understand the materiaal.

Note, you like using the term "Learned by Rote". Well, statements
"Learned by rote" tend to be statements that are accepted true.

Until you can show where they are incorrect in this case, siteing other
accepted statements, CORRECTLY interpreted, you can't dismiss them as
just "Learned by rote".

Note also, I do NOT "learn by rote", and in fact, have a slight
disability that I have a very hard time "learning by rote". I need to
know WHY something works and understand the basic princples, and then I
can remember it.

Your problem seems to be that you never learned the material in the
first place, but are working in a universe where you are GUESSING as to
what things mean, and thus since you don't actually KNOW what people are
talking about with statements, you get things wrong.

Your talk of "First Principles" is off, "First Principles" is a method
where you START by LEARNING the actual fundamentals, and learning them
welll. Then you move forward using those basics and try to not rest on
the directions that others took in deciding how to Engineer a solution
to the problem.

It needs the study of the actual First Principles, or it becomes just an
exercise in fantasy.

That is what you have done, you didn't learn the basic principles, and
are just repeating the errors of a century ago. You have refused to
learn from History, and are repeating it.

On 11/30/2022 6:01 AM, Richard Damon wrote:
> On 11/29/22 11:38 PM, olcott wrote:
>> On 11/29/2022 10:03 PM, Richard Damon wrote:
>>> On 11/29/22 10:29 PM, olcott wrote:
>>>> On 11/29/2022 8:54 PM, Richard Damon wrote:
>>>>> On 11/29/22 9:30 PM, olcott wrote:
>>>>>> On 11/29/2022 7:48 PM, Richard Damon wrote:
>>>>>>> On 11/29/22 7:52 PM, olcott wrote:
>>>>>>>> On 11/29/2022 5:47 PM, Richard Damon wrote:
>>>>>>>>> On 11/29/22 11:35 AM, olcott wrote:
>>>>>>>>>> On 11/28/2022 11:56 AM, olcott wrote:
>>>>>>>>>>> void D(void (*x)())
>>>>>>>>>>> {
>>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>    return;
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> int main()
>>>>>>>>>>> {
>>>>>>>>>>>    D(D);
>>>>>>>>>>>    H(D, D);
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> The fact that no D(D) ever stops running unless H(D,D) aborts
>>>>>>>>>>> the simlation of its input conclusively proves that the input
>>>>>>>>>>> to H(D,D) specifies a non-halting sequence of configurations.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> [Ignoring stack overflow]
>>>>>>>>>>
>>>>>>>>>> The above D(D) never stops running unless the H(D,D) that it
>>>>>>>>>> invokes aborts the simulation of its input.
>>>>>>>>>
>>>>>>>>> Right, but that is ok, and doesn't make that D non-halting by
>>>>>>>>> the DEFINITION of what a Halt Decider needs to ddcide.
>>>>>>>>>
>>>>>>>>> H(M,x) needs to return Halting if M(x) Halts.
>>>>>>>>>
>>>>>>>>> Since D(D) halts, this means that H(D,D) needs to return Halting.
>>>>>>>>>
>>>>>>>>> Nothing in that ask anything about D using a simulation that
>>>>>>>>> happens to be aborted.
>>>>>>>>>
>>>>>>>>> You are just using wrong definitions.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> D(D) correctly simulated by the above H(D,D) never stops
>>>>>>>>>> running unless aborted.
>>>>>>>>>
>>>>>>>>> Nope, UTM(D,D) which is the DEFINITION of a "Correct
>>>>>>>>> Simulation" will Halt. Thus the "Correct Simulation" of this
>>>>>>>>> input WILL HALT.
>>>>>>>>>
>>>>>>>>> The H you have provided never does a correct wsimulation, so
>>>>>>>>> what it does is actually irrelevent.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Thus no D(D) ever stops running unless an H(D,D) aborts the
>>>>>>>>>> simulation of its input.
>>>>>>>>>
>>>>>>>>> Nope, since the H(D,D) that D calls DOES abort its simulation,
>>>>>>>>> the H(D,D) simulating this D didn't actually NEED to abort its
>>>>>>>>> simulation,
>>>>>>>>
>>>>>>>> You are not paying close enough attention to the exact words
>>>>>>>> that I just said.
>>>>>>>>
>>>>>>>> If No H(D,D) in the universe ever stops simulating its input
>>>>>>>> then no corresponding executed or simulated D(D) in the universe
>>>>>>>> ever stops running.
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> So, you are just PROVING that you are not working on the Halting
>>>>>>> Problem, because that isn't the Halting Problem criteria.
>>>>>>>
>>>>>>
>>>>>> I have already shown that people having a much deeper
>>>>>> understanding than the mere rote memorization of textbooks
>>>>>> understand that my adaptation of the halt status criteria is
>>>>>> equivalent to the conventional notions.
>>>>>>
>>>>>>
>>>>>
>>>>> Nope. You are perhaps DECEIVED them into giving assent to a
>>>>> statement whixh appears to match the actual definition but doesn't
>>>>> with your unusual meaning of the words.
>>>>>
>>>>
>>>> He has written a textbook on the subject and many many papers,
>>>> It is ridiculous to believe that:
>>>> (a) He could be fooled into agreeing with a statement that he
>>>>      did not fully understand.
>>>> AND
>>>> (b) Give me permission to quote his agreement with this statement.
>>>>
>>>> I do not believe that Ben believed that he was fooled when Ben made
>>>> the claim that he was fooled. Ben knows better than this. Ben simply
>>>> ran out of options for rebuttal and thus grasped at straws.
>>>>
>>>>
>>>
>>> Right, and he agreed that if H shows that the CORRECT SIMULATION of
>>> its input is non-halting, which is the simulation by a UTM. H only
>>> does a correct simulaition if its simulation agrees with THAT
>>> simulation.
>>>
>>
>> I am only willing to have a mutually honest dialogue.
>>
>
> I'm AM being Honest.
>
>> When I prove that you are incorrect on a point you never acknowledge
>> that I proved that you are incorrect you simply change the subject.
>
> Except that you never have proven me wrong on any major point.
>
>>
>> Acknowledge that he was not fooled and that he most likely fully
>> understood what he agreed to or we cannot move on to the next point.
>>
>
> "Fooled" may be a stronger word then needed. He does not interpret the
> words the way you do. This is in part due to your enforced IGNORANCE of
> the subject.

Until you acknowledge that you were wrong and he was not fooled at all
we cannot proceed.

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

On 11/30/22 9:38 AM, olcott wrote:
> On 11/30/2022 6:01 AM, Richard Damon wrote:
>> On 11/29/22 11:38 PM, olcott wrote:
>>> On 11/29/2022 10:03 PM, Richard Damon wrote:
>>>> On 11/29/22 10:29 PM, olcott wrote:
>>>>> On 11/29/2022 8:54 PM, Richard Damon wrote:
>>>>>> On 11/29/22 9:30 PM, olcott wrote:
>>>>>>> On 11/29/2022 7:48 PM, Richard Damon wrote:
>>>>>>>> On 11/29/22 7:52 PM, olcott wrote:
>>>>>>>>> On 11/29/2022 5:47 PM, Richard Damon wrote:
>>>>>>>>>> On 11/29/22 11:35 AM, olcott wrote:
>>>>>>>>>>> On 11/28/2022 11:56 AM, olcott wrote:
>>>>>>>>>>>> void D(void (*x)())
>>>>>>>>>>>> {
>>>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>    return;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> int main()
>>>>>>>>>>>> {
>>>>>>>>>>>>    D(D);
>>>>>>>>>>>>    H(D, D);
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> The fact that no D(D) ever stops running unless H(D,D)
>>>>>>>>>>>> aborts the simlation of its input conclusively proves that
>>>>>>>>>>>> the input to H(D,D) specifies a non-halting sequence of
>>>>>>>>>>>> configurations.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> [Ignoring stack overflow]
>>>>>>>>>>>
>>>>>>>>>>> The above D(D) never stops running unless the H(D,D) that it
>>>>>>>>>>> invokes aborts the simulation of its input.
>>>>>>>>>>
>>>>>>>>>> Right, but that is ok, and doesn't make that D non-halting by
>>>>>>>>>> the DEFINITION of what a Halt Decider needs to ddcide.
>>>>>>>>>>
>>>>>>>>>> H(M,x) needs to return Halting if M(x) Halts.
>>>>>>>>>>
>>>>>>>>>> Since D(D) halts, this means that H(D,D) needs to return Halting.
>>>>>>>>>>
>>>>>>>>>> Nothing in that ask anything about D using a simulation that
>>>>>>>>>> happens to be aborted.
>>>>>>>>>>
>>>>>>>>>> You are just using wrong definitions.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> D(D) correctly simulated by the above H(D,D) never stops
>>>>>>>>>>> running unless aborted.
>>>>>>>>>>
>>>>>>>>>> Nope, UTM(D,D) which is the DEFINITION of a "Correct
>>>>>>>>>> Simulation" will Halt. Thus the "Correct Simulation" of this
>>>>>>>>>> input WILL HALT.
>>>>>>>>>>
>>>>>>>>>> The H you have provided never does a correct wsimulation, so
>>>>>>>>>> what it does is actually irrelevent.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Thus no D(D) ever stops running unless an H(D,D) aborts the
>>>>>>>>>>> simulation of its input.
>>>>>>>>>>
>>>>>>>>>> Nope, since the H(D,D) that D calls DOES abort its simulation,
>>>>>>>>>> the H(D,D) simulating this D didn't actually NEED to abort its
>>>>>>>>>> simulation,
>>>>>>>>>
>>>>>>>>> You are not paying close enough attention to the exact words
>>>>>>>>> that I just said.
>>>>>>>>>
>>>>>>>>> If No H(D,D) in the universe ever stops simulating its input
>>>>>>>>> then no corresponding executed or simulated D(D) in the
>>>>>>>>> universe ever stops running.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> So, you are just PROVING that you are not working on the Halting
>>>>>>>> Problem, because that isn't the Halting Problem criteria.
>>>>>>>>
>>>>>>>
>>>>>>> I have already shown that people having a much deeper
>>>>>>> understanding than the mere rote memorization of textbooks
>>>>>>> understand that my adaptation of the halt status criteria is
>>>>>>> equivalent to the conventional notions.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Nope. You are perhaps DECEIVED them into giving assent to a
>>>>>> statement whixh appears to match the actual definition but doesn't
>>>>>> with your unusual meaning of the words.
>>>>>>
>>>>>
>>>>> He has written a textbook on the subject and many many papers,
>>>>> It is ridiculous to believe that:
>>>>> (a) He could be fooled into agreeing with a statement that he
>>>>>      did not fully understand.
>>>>> AND
>>>>> (b) Give me permission to quote his agreement with this statement.
>>>>>
>>>>> I do not believe that Ben believed that he was fooled when Ben made
>>>>> the claim that he was fooled. Ben knows better than this. Ben
>>>>> simply ran out of options for rebuttal and thus grasped at straws.
>>>>>
>>>>>
>>>>
>>>> Right, and he agreed that if H shows that the CORRECT SIMULATION of
>>>> its input is non-halting, which is the simulation by a UTM. H only
>>>> does a correct simulaition if its simulation agrees with THAT
>>>> simulation.
>>>>
>>>
>>> I am only willing to have a mutually honest dialogue.
>>>
>>
>> I'm AM being Honest.
>>
>>> When I prove that you are incorrect on a point you never acknowledge
>>> that I proved that you are incorrect you simply change the subject.
>>
>> Except that you never have proven me wrong on any major point.
>>
>>>
>>> Acknowledge that he was not fooled and that he most likely fully
>>> understood what he agreed to or we cannot move on to the next point.
>>>
>>
>> "Fooled" may be a stronger word then needed. He does not interpret the
>> words the way you do. This is in part due to your enforced IGNORANCE
>> of the subject.
>
> Until you acknowledge that you were wrong and he was not fooled at all
> we cannot proceed.
>

No, untill YOU acknowledge that you don't understand the actual meaning
of the words, in context, that you have been using, you are just going
to continue to show your stupidity.

Remember, To Prof Sipser, "Correct Simulation" means a Complete and
Correct Simulation, just like a UTM.

Since even you admit that D(D) returns when H(D,D) answers 0, this means
that since you are claiming your "correct H" does answer 0, then the
D(D) of this problem Halts, and thuis the ONLY possible results of a
"Correct Simulation" of the input to H(D,D) is Halting, so it is
IMPOSSIBLE for H to "Correct Determine that a Correct Simulaiton of its
input would be non-halting". This applies whether you restrict that
correct simulation to being by H or not.

Thus, your arguement FAILS.

Yes, if H COULD prove that, it would be correct, because that means that
the D given it must have been some other machine that doesn't halt, but
your proof stipulates that it IS the machine that was described in his
proof, which DOES call the H that is claimed to be correct, and which by
your stipulation DOES abort its simulaition and return 0.

On 11/30/2022 6:09 PM, Richard Damon wrote:
> On 11/30/22 9:38 AM, olcott wrote:
>> On 11/30/2022 6:01 AM, Richard Damon wrote:
>>> On 11/29/22 11:38 PM, olcott wrote:
>>>> On 11/29/2022 10:03 PM, Richard Damon wrote:
>>>>> On 11/29/22 10:29 PM, olcott wrote:
>>>>>> On 11/29/2022 8:54 PM, Richard Damon wrote:
>>>>>>> On 11/29/22 9:30 PM, olcott wrote:
>>>>>>>> On 11/29/2022 7:48 PM, Richard Damon wrote:
>>>>>>>>> On 11/29/22 7:52 PM, olcott wrote:
>>>>>>>>>> On 11/29/2022 5:47 PM, Richard Damon wrote:
>>>>>>>>>>> On 11/29/22 11:35 AM, olcott wrote:
>>>>>>>>>>>> On 11/28/2022 11:56 AM, olcott wrote:
>>>>>>>>>>>>> void D(void (*x)())
>>>>>>>>>>>>> {
>>>>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>>    return;
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> int main()
>>>>>>>>>>>>> {
>>>>>>>>>>>>>    D(D);
>>>>>>>>>>>>>    H(D, D);
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> The fact that no D(D) ever stops running unless H(D,D)
>>>>>>>>>>>>> aborts the simlation of its input conclusively proves that
>>>>>>>>>>>>> the input to H(D,D) specifies a non-halting sequence of
>>>>>>>>>>>>> configurations.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> [Ignoring stack overflow]
>>>>>>>>>>>>
>>>>>>>>>>>> The above D(D) never stops running unless the H(D,D) that it
>>>>>>>>>>>> invokes aborts the simulation of its input.
>>>>>>>>>>>
>>>>>>>>>>> Right, but that is ok, and doesn't make that D non-halting by
>>>>>>>>>>> the DEFINITION of what a Halt Decider needs to ddcide.
>>>>>>>>>>>
>>>>>>>>>>> H(M,x) needs to return Halting if M(x) Halts.
>>>>>>>>>>>
>>>>>>>>>>> Since D(D) halts, this means that H(D,D) needs to return
>>>>>>>>>>> Halting.
>>>>>>>>>>>
>>>>>>>>>>> Nothing in that ask anything about D using a simulation that
>>>>>>>>>>> happens to be aborted.
>>>>>>>>>>>
>>>>>>>>>>> You are just using wrong definitions.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> D(D) correctly simulated by the above H(D,D) never stops
>>>>>>>>>>>> running unless aborted.
>>>>>>>>>>>
>>>>>>>>>>> Nope, UTM(D,D) which is the DEFINITION of a "Correct
>>>>>>>>>>> Simulation" will Halt. Thus the "Correct Simulation" of this
>>>>>>>>>>> input WILL HALT.
>>>>>>>>>>>
>>>>>>>>>>> The H you have provided never does a correct wsimulation, so
>>>>>>>>>>> what it does is actually irrelevent.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Thus no D(D) ever stops running unless an H(D,D) aborts the
>>>>>>>>>>>> simulation of its input.
>>>>>>>>>>>
>>>>>>>>>>> Nope, since the H(D,D) that D calls DOES abort its
>>>>>>>>>>> simulation, the H(D,D) simulating this D didn't actually NEED
>>>>>>>>>>> to abort its simulation,
>>>>>>>>>>
>>>>>>>>>> You are not paying close enough attention to the exact words
>>>>>>>>>> that I just said.
>>>>>>>>>>
>>>>>>>>>> If No H(D,D) in the universe ever stops simulating its input
>>>>>>>>>> then no corresponding executed or simulated D(D) in the
>>>>>>>>>> universe ever stops running.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> So, you are just PROVING that you are not working on the
>>>>>>>>> Halting Problem, because that isn't the Halting Problem criteria.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I have already shown that people having a much deeper
>>>>>>>> understanding than the mere rote memorization of textbooks
>>>>>>>> understand that my adaptation of the halt status criteria is
>>>>>>>> equivalent to the conventional notions.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Nope. You are perhaps DECEIVED them into giving assent to a
>>>>>>> statement whixh appears to match the actual definition but
>>>>>>> doesn't with your unusual meaning of the words.
>>>>>>>
>>>>>>
>>>>>> He has written a textbook on the subject and many many papers,
>>>>>> It is ridiculous to believe that:
>>>>>> (a) He could be fooled into agreeing with a statement that he
>>>>>>      did not fully understand.
>>>>>> AND
>>>>>> (b) Give me permission to quote his agreement with this statement.
>>>>>>
>>>>>> I do not believe that Ben believed that he was fooled when Ben
>>>>>> made the claim that he was fooled. Ben knows better than this. Ben
>>>>>> simply ran out of options for rebuttal and thus grasped at straws.
>>>>>>
>>>>>>
>>>>>
>>>>> Right, and he agreed that if H shows that the CORRECT SIMULATION of
>>>>> its input is non-halting, which is the simulation by a UTM. H only
>>>>> does a correct simulaition if its simulation agrees with THAT
>>>>> simulation.
>>>>>
>>>>
>>>> I am only willing to have a mutually honest dialogue.
>>>>
>>>
>>> I'm AM being Honest.
>>>
>>>> When I prove that you are incorrect on a point you never acknowledge
>>>> that I proved that you are incorrect you simply change the subject.
>>>
>>> Except that you never have proven me wrong on any major point.
>>>
>>>>
>>>> Acknowledge that he was not fooled and that he most likely fully
>>>> understood what he agreed to or we cannot move on to the next point.
>>>>
>>>
>>> "Fooled" may be a stronger word then needed. He does not interpret
>>> the words the way you do. This is in part due to your enforced
>>> IGNORANCE of the subject.
>>
>> Until you acknowledge that you were wrong and he was not fooled at all
>> we cannot proceed.
>>
>
> No, untill YOU acknowledge that you don't understand the actual meaning
> of the words, in context, that you have been using, you are just going
> to continue to show your stupidity.
>
OK so you don't want to talk anymore, that is fine with me.

--
Copyright 2022 Olcott

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

On 11/30/22 7:29 PM, olcott wrote:
> On 11/30/2022 6:09 PM, Richard Damon wrote:
>> On 11/30/22 9:38 AM, olcott wrote:
>>> On 11/30/2022 6:01 AM, Richard Damon wrote:
>>>> On 11/29/22 11:38 PM, olcott wrote:
>>>>> On 11/29/2022 10:03 PM, Richard Damon wrote:
>>>>>> On 11/29/22 10:29 PM, olcott wrote:
>>>>>>> On 11/29/2022 8:54 PM, Richard Damon wrote:
>>>>>>>> On 11/29/22 9:30 PM, olcott wrote:
>>>>>>>>> On 11/29/2022 7:48 PM, Richard Damon wrote:
>>>>>>>>>> On 11/29/22 7:52 PM, olcott wrote:
>>>>>>>>>>> On 11/29/2022 5:47 PM, Richard Damon wrote:
>>>>>>>>>>>> On 11/29/22 11:35 AM, olcott wrote:
>>>>>>>>>>>>> On 11/28/2022 11:56 AM, olcott wrote:
>>>>>>>>>>>>>> void D(void (*x)())
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>>>    return;
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>    D(D);
>>>>>>>>>>>>>>    H(D, D);
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The fact that no D(D) ever stops running unless H(D,D)
>>>>>>>>>>>>>> aborts the simlation of its input conclusively proves that
>>>>>>>>>>>>>> the input to H(D,D) specifies a non-halting sequence of
>>>>>>>>>>>>>> configurations.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> [Ignoring stack overflow]
>>>>>>>>>>>>>
>>>>>>>>>>>>> The above D(D) never stops running unless the H(D,D) that
>>>>>>>>>>>>> it invokes aborts the simulation of its input.
>>>>>>>>>>>>
>>>>>>>>>>>> Right, but that is ok, and doesn't make that D non-halting
>>>>>>>>>>>> by the DEFINITION of what a Halt Decider needs to ddcide.
>>>>>>>>>>>>
>>>>>>>>>>>> H(M,x) needs to return Halting if M(x) Halts.
>>>>>>>>>>>>
>>>>>>>>>>>> Since D(D) halts, this means that H(D,D) needs to return
>>>>>>>>>>>> Halting.
>>>>>>>>>>>>
>>>>>>>>>>>> Nothing in that ask anything about D using a simulation that
>>>>>>>>>>>> happens to be aborted.
>>>>>>>>>>>>
>>>>>>>>>>>> You are just using wrong definitions.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> D(D) correctly simulated by the above H(D,D) never stops
>>>>>>>>>>>>> running unless aborted.
>>>>>>>>>>>>
>>>>>>>>>>>> Nope, UTM(D,D) which is the DEFINITION of a "Correct
>>>>>>>>>>>> Simulation" will Halt. Thus the "Correct Simulation" of this
>>>>>>>>>>>> input WILL HALT.
>>>>>>>>>>>>
>>>>>>>>>>>> The H you have provided never does a correct wsimulation, so
>>>>>>>>>>>> what it does is actually irrelevent.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Thus no D(D) ever stops running unless an H(D,D) aborts the
>>>>>>>>>>>>> simulation of its input.
>>>>>>>>>>>>
>>>>>>>>>>>> Nope, since the H(D,D) that D calls DOES abort its
>>>>>>>>>>>> simulation, the H(D,D) simulating this D didn't actually
>>>>>>>>>>>> NEED to abort its simulation,
>>>>>>>>>>>
>>>>>>>>>>> You are not paying close enough attention to the exact words
>>>>>>>>>>> that I just said.
>>>>>>>>>>>
>>>>>>>>>>> If No H(D,D) in the universe ever stops simulating its input
>>>>>>>>>>> then no corresponding executed or simulated D(D) in the
>>>>>>>>>>> universe ever stops running.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> So, you are just PROVING that you are not working on the
>>>>>>>>>> Halting Problem, because that isn't the Halting Problem criteria.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I have already shown that people having a much deeper
>>>>>>>>> understanding than the mere rote memorization of textbooks
>>>>>>>>> understand that my adaptation of the halt status criteria is
>>>>>>>>> equivalent to the conventional notions.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Nope. You are perhaps DECEIVED them into giving assent to a
>>>>>>>> statement whixh appears to match the actual definition but
>>>>>>>> doesn't with your unusual meaning of the words.
>>>>>>>>
>>>>>>>
>>>>>>> He has written a textbook on the subject and many many papers,
>>>>>>> It is ridiculous to believe that:
>>>>>>> (a) He could be fooled into agreeing with a statement that he
>>>>>>>      did not fully understand.
>>>>>>> AND
>>>>>>> (b) Give me permission to quote his agreement with this statement.
>>>>>>>
>>>>>>> I do not believe that Ben believed that he was fooled when Ben
>>>>>>> made the claim that he was fooled. Ben knows better than this.
>>>>>>> Ben simply ran out of options for rebuttal and thus grasped at
>>>>>>> straws.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Right, and he agreed that if H shows that the CORRECT SIMULATION
>>>>>> of its input is non-halting, which is the simulation by a UTM. H
>>>>>> only does a correct simulaition if its simulation agrees with THAT
>>>>>> simulation.
>>>>>>
>>>>>
>>>>> I am only willing to have a mutually honest dialogue.
>>>>>
>>>>
>>>> I'm AM being Honest.
>>>>
>>>>> When I prove that you are incorrect on a point you never
>>>>> acknowledge that I proved that you are incorrect you simply change
>>>>> the subject.
>>>>
>>>> Except that you never have proven me wrong on any major point.
>>>>
>>>>>
>>>>> Acknowledge that he was not fooled and that he most likely fully
>>>>> understood what he agreed to or we cannot move on to the next point.
>>>>>
>>>>
>>>> "Fooled" may be a stronger word then needed. He does not interpret
>>>> the words the way you do. This is in part due to your enforced
>>>> IGNORANCE of the subject.
>>>
>>> Until you acknowledge that you were wrong and he was not fooled at
>>> all we cannot proceed.
>>>
>>
>> No, untill YOU acknowledge that you don't understand the actual
>> meaning of the words, in context, that you have been using, you are
>> just going to continue to show your stupidity.
>>
> OK so you don't want to talk anymore, that is fine with me.
>

On 11/30/2022 7:00 PM, Richard Damon wrote:
> On 11/30/22 7:29 PM, olcott wrote:
>> On 11/30/2022 6:09 PM, Richard Damon wrote:
>>> On 11/30/22 9:38 AM, olcott wrote:
>>>> On 11/30/2022 6:01 AM, Richard Damon wrote:
>>>>> On 11/29/22 11:38 PM, olcott wrote:
>>>>>> On 11/29/2022 10:03 PM, Richard Damon wrote:
>>>>>>> On 11/29/22 10:29 PM, olcott wrote:
>>>>>>>> On 11/29/2022 8:54 PM, Richard Damon wrote:
>>>>>>>>> On 11/29/22 9:30 PM, olcott wrote:
>>>>>>>>>> On 11/29/2022 7:48 PM, Richard Damon wrote:
>>>>>>>>>>> On 11/29/22 7:52 PM, olcott wrote:
>>>>>>>>>>>> On 11/29/2022 5:47 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 11/29/22 11:35 AM, olcott wrote:
>>>>>>>>>>>>>> On 11/28/2022 11:56 AM, olcott wrote:
>>>>>>>>>>>>>>> void D(void (*x)())
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>>>>    return;
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>    D(D);
>>>>>>>>>>>>>>>    H(D, D);
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The fact that no D(D) ever stops running unless H(D,D)
>>>>>>>>>>>>>>> aborts the simlation of its input conclusively proves
>>>>>>>>>>>>>>> that the input to H(D,D) specifies a non-halting sequence
>>>>>>>>>>>>>>> of configurations.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> [Ignoring stack overflow]
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The above D(D) never stops running unless the H(D,D) that
>>>>>>>>>>>>>> it invokes aborts the simulation of its input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Right, but that is ok, and doesn't make that D non-halting
>>>>>>>>>>>>> by the DEFINITION of what a Halt Decider needs to ddcide.
>>>>>>>>>>>>>
>>>>>>>>>>>>> H(M,x) needs to return Halting if M(x) Halts.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Since D(D) halts, this means that H(D,D) needs to return
>>>>>>>>>>>>> Halting.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nothing in that ask anything about D using a simulation
>>>>>>>>>>>>> that happens to be aborted.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You are just using wrong definitions.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> D(D) correctly simulated by the above H(D,D) never stops
>>>>>>>>>>>>>> running unless aborted.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope, UTM(D,D) which is the DEFINITION of a "Correct
>>>>>>>>>>>>> Simulation" will Halt. Thus the "Correct Simulation" of
>>>>>>>>>>>>> this input WILL HALT.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The H you have provided never does a correct wsimulation,
>>>>>>>>>>>>> so what it does is actually irrelevent.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Thus no D(D) ever stops running unless an H(D,D) aborts
>>>>>>>>>>>>>> the simulation of its input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope, since the H(D,D) that D calls DOES abort its
>>>>>>>>>>>>> simulation, the H(D,D) simulating this D didn't actually
>>>>>>>>>>>>> NEED to abort its simulation,
>>>>>>>>>>>>
>>>>>>>>>>>> You are not paying close enough attention to the exact words
>>>>>>>>>>>> that I just said.
>>>>>>>>>>>>
>>>>>>>>>>>> If No H(D,D) in the universe ever stops simulating its input
>>>>>>>>>>>> then no corresponding executed or simulated D(D) in the
>>>>>>>>>>>> universe ever stops running.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> So, you are just PROVING that you are not working on the
>>>>>>>>>>> Halting Problem, because that isn't the Halting Problem
>>>>>>>>>>> criteria.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I have already shown that people having a much deeper
>>>>>>>>>> understanding than the mere rote memorization of textbooks
>>>>>>>>>> understand that my adaptation of the halt status criteria is
>>>>>>>>>> equivalent to the conventional notions.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Nope. You are perhaps DECEIVED them into giving assent to a
>>>>>>>>> statement whixh appears to match the actual definition but
>>>>>>>>> doesn't with your unusual meaning of the words.
>>>>>>>>>
>>>>>>>>
>>>>>>>> He has written a textbook on the subject and many many papers,
>>>>>>>> It is ridiculous to believe that:
>>>>>>>> (a) He could be fooled into agreeing with a statement that he
>>>>>>>>      did not fully understand.
>>>>>>>> AND
>>>>>>>> (b) Give me permission to quote his agreement with this statement.
>>>>>>>>
>>>>>>>> I do not believe that Ben believed that he was fooled when Ben
>>>>>>>> made the claim that he was fooled. Ben knows better than this.
>>>>>>>> Ben simply ran out of options for rebuttal and thus grasped at
>>>>>>>> straws.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Right, and he agreed that if H shows that the CORRECT SIMULATION
>>>>>>> of its input is non-halting, which is the simulation by a UTM. H
>>>>>>> only does a correct simulaition if its simulation agrees with
>>>>>>> THAT simulation.
>>>>>>>
>>>>>>
>>>>>> I am only willing to have a mutually honest dialogue.
>>>>>>
>>>>>
>>>>> I'm AM being Honest.
>>>>>
>>>>>> When I prove that you are incorrect on a point you never
>>>>>> acknowledge that I proved that you are incorrect you simply change
>>>>>> the subject.
>>>>>
>>>>> Except that you never have proven me wrong on any major point.
>>>>>
>>>>>>
>>>>>> Acknowledge that he was not fooled and that he most likely fully
>>>>>> understood what he agreed to or we cannot move on to the next point.
>>>>>>
>>>>>
>>>>> "Fooled" may be a stronger word then needed. He does not interpret
>>>>> the words the way you do. This is in part due to your enforced
>>>>> IGNORANCE of the subject.
>>>>
>>>> Until you acknowledge that you were wrong and he was not fooled at
>>>> all we cannot proceed.
>>>>
>>>
>>> No, untill YOU acknowledge that you don't understand the actual
>>> meaning of the words, in context, that you have been using, you are
>>> just going to continue to show your stupidity.
>>>
>> OK so you don't want to talk anymore, that is fine with me.
>>
>
>
> I will point out that I have nothing to prove, as the Halting Theory, as
> proved, is on my side.
>
> Everything I have said, is just a restating of the accepted Truth.
>

On 11/30/22 8:07 PM, olcott wrote:
> On 11/30/2022 7:00 PM, Richard Damon wrote:
>> On 11/30/22 7:29 PM, olcott wrote:
>>> On 11/30/2022 6:09 PM, Richard Damon wrote:
>>>> On 11/30/22 9:38 AM, olcott wrote:
>>>>> On 11/30/2022 6:01 AM, Richard Damon wrote:
>>>>>> On 11/29/22 11:38 PM, olcott wrote:
>>>>>>> On 11/29/2022 10:03 PM, Richard Damon wrote:
>>>>>>>> On 11/29/22 10:29 PM, olcott wrote:
>>>>>>>>> On 11/29/2022 8:54 PM, Richard Damon wrote:
>>>>>>>>>> On 11/29/22 9:30 PM, olcott wrote:
>>>>>>>>>>> On 11/29/2022 7:48 PM, Richard Damon wrote:
>>>>>>>>>>>> On 11/29/22 7:52 PM, olcott wrote:
>>>>>>>>>>>>> On 11/29/2022 5:47 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 11/29/22 11:35 AM, olcott wrote:
>>>>>>>>>>>>>>> On 11/28/2022 11:56 AM, olcott wrote:
>>>>>>>>>>>>>>>> void D(void (*x)())
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>>>>>    return;
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>    D(D);
>>>>>>>>>>>>>>>>    H(D, D);
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The fact that no D(D) ever stops running unless H(D,D)
>>>>>>>>>>>>>>>> aborts the simlation of its input conclusively proves
>>>>>>>>>>>>>>>> that the input to H(D,D) specifies a non-halting
>>>>>>>>>>>>>>>> sequence of configurations.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> [Ignoring stack overflow]
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The above D(D) never stops running unless the H(D,D) that
>>>>>>>>>>>>>>> it invokes aborts the simulation of its input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Right, but that is ok, and doesn't make that D non-halting
>>>>>>>>>>>>>> by the DEFINITION of what a Halt Decider needs to ddcide.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H(M,x) needs to return Halting if M(x) Halts.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Since D(D) halts, this means that H(D,D) needs to return
>>>>>>>>>>>>>> Halting.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Nothing in that ask anything about D using a simulation
>>>>>>>>>>>>>> that happens to be aborted.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You are just using wrong definitions.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> D(D) correctly simulated by the above H(D,D) never stops
>>>>>>>>>>>>>>> running unless aborted.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Nope, UTM(D,D) which is the DEFINITION of a "Correct
>>>>>>>>>>>>>> Simulation" will Halt. Thus the "Correct Simulation" of
>>>>>>>>>>>>>> this input WILL HALT.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The H you have provided never does a correct wsimulation,
>>>>>>>>>>>>>> so what it does is actually irrelevent.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Thus no D(D) ever stops running unless an H(D,D) aborts
>>>>>>>>>>>>>>> the simulation of its input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Nope, since the H(D,D) that D calls DOES abort its
>>>>>>>>>>>>>> simulation, the H(D,D) simulating this D didn't actually
>>>>>>>>>>>>>> NEED to abort its simulation,
>>>>>>>>>>>>>
>>>>>>>>>>>>> You are not paying close enough attention to the exact
>>>>>>>>>>>>> words that I just said.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If No H(D,D) in the universe ever stops simulating its
>>>>>>>>>>>>> input then no corresponding executed or simulated D(D) in
>>>>>>>>>>>>> the universe ever stops running.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> So, you are just PROVING that you are not working on the
>>>>>>>>>>>> Halting Problem, because that isn't the Halting Problem
>>>>>>>>>>>> criteria.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> I have already shown that people having a much deeper
>>>>>>>>>>> understanding than the mere rote memorization of textbooks
>>>>>>>>>>> understand that my adaptation of the halt status criteria is
>>>>>>>>>>> equivalent to the conventional notions.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Nope. You are perhaps DECEIVED them into giving assent to a
>>>>>>>>>> statement whixh appears to match the actual definition but
>>>>>>>>>> doesn't with your unusual meaning of the words.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> He has written a textbook on the subject and many many papers,
>>>>>>>>> It is ridiculous to believe that:
>>>>>>>>> (a) He could be fooled into agreeing with a statement that he
>>>>>>>>>      did not fully understand.
>>>>>>>>> AND
>>>>>>>>> (b) Give me permission to quote his agreement with this statement.
>>>>>>>>>
>>>>>>>>> I do not believe that Ben believed that he was fooled when Ben
>>>>>>>>> made the claim that he was fooled. Ben knows better than this.
>>>>>>>>> Ben simply ran out of options for rebuttal and thus grasped at
>>>>>>>>> straws.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Right, and he agreed that if H shows that the CORRECT SIMULATION
>>>>>>>> of its input is non-halting, which is the simulation by a UTM. H
>>>>>>>> only does a correct simulaition if its simulation agrees with
>>>>>>>> THAT simulation.
>>>>>>>>
>>>>>>>
>>>>>>> I am only willing to have a mutually honest dialogue.
>>>>>>>
>>>>>>
>>>>>> I'm AM being Honest.
>>>>>>
>>>>>>> When I prove that you are incorrect on a point you never
>>>>>>> acknowledge that I proved that you are incorrect you simply
>>>>>>> change the subject.
>>>>>>
>>>>>> Except that you never have proven me wrong on any major point.
>>>>>>
>>>>>>>
>>>>>>> Acknowledge that he was not fooled and that he most likely fully
>>>>>>> understood what he agreed to or we cannot move on to the next point.
>>>>>>>
>>>>>>
>>>>>> "Fooled" may be a stronger word then needed. He does not interpret
>>>>>> the words the way you do. This is in part due to your enforced
>>>>>> IGNORANCE of the subject.
>>>>>
>>>>> Until you acknowledge that you were wrong and he was not fooled at
>>>>> all we cannot proceed.
>>>>>
>>>>
>>>> No, untill YOU acknowledge that you don't understand the actual
>>>> meaning of the words, in context, that you have been using, you are
>>>> just going to continue to show your stupidity.
>>>>
>>> OK so you don't want to talk anymore, that is fine with me.
>>>
>>
>>
>> I will point out that I have nothing to prove, as the Halting Theory,
>> as proved, is on my side.
>>
>> Everything I have said, is just a restating of the accepted Truth.
>>
>
> You refuse to acknowledge any of the points where I am proved to be
> correct because you (as everyone else here) are only interested in
> rebuttal, thus have no interest what-so-ever in an honest dialogue.
>
> This is intolerable.
>

On 11/30/2022 7:29 PM, Richard Damon wrote:
> On 11/30/22 8:07 PM, olcott wrote:
>> On 11/30/2022 7:00 PM, Richard Damon wrote:
>>> On 11/30/22 7:29 PM, olcott wrote:
>>>> On 11/30/2022 6:09 PM, Richard Damon wrote:
>>>>> On 11/30/22 9:38 AM, olcott wrote:
>>>>>> On 11/30/2022 6:01 AM, Richard Damon wrote:
>>>>>>> On 11/29/22 11:38 PM, olcott wrote:
>>>>>>>> On 11/29/2022 10:03 PM, Richard Damon wrote:
>>>>>>>>> On 11/29/22 10:29 PM, olcott wrote:
>>>>>>>>>> On 11/29/2022 8:54 PM, Richard Damon wrote:
>>>>>>>>>>> On 11/29/22 9:30 PM, olcott wrote:
>>>>>>>>>>>> On 11/29/2022 7:48 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 11/29/22 7:52 PM, olcott wrote:
>>>>>>>>>>>>>> On 11/29/2022 5:47 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 11/29/22 11:35 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 11/28/2022 11:56 AM, olcott wrote:
>>>>>>>>>>>>>>>>> void D(void (*x)())
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>>>>>>    return;
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>    D(D);
>>>>>>>>>>>>>>>>>    H(D, D);
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The fact that no D(D) ever stops running unless H(D,D)
>>>>>>>>>>>>>>>>> aborts the simlation of its input conclusively proves
>>>>>>>>>>>>>>>>> that the input to H(D,D) specifies a non-halting
>>>>>>>>>>>>>>>>> sequence of configurations.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> [Ignoring stack overflow]
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The above D(D) never stops running unless the H(D,D)
>>>>>>>>>>>>>>>> that it invokes aborts the simulation of its input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Right, but that is ok, and doesn't make that D
>>>>>>>>>>>>>>> non-halting by the DEFINITION of what a Halt Decider
>>>>>>>>>>>>>>> needs to ddcide.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H(M,x) needs to return Halting if M(x) Halts.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Since D(D) halts, this means that H(D,D) needs to return
>>>>>>>>>>>>>>> Halting.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Nothing in that ask anything about D using a simulation
>>>>>>>>>>>>>>> that happens to be aborted.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You are just using wrong definitions.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> D(D) correctly simulated by the above H(D,D) never stops
>>>>>>>>>>>>>>>> running unless aborted.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Nope, UTM(D,D) which is the DEFINITION of a "Correct
>>>>>>>>>>>>>>> Simulation" will Halt. Thus the "Correct Simulation" of
>>>>>>>>>>>>>>> this input WILL HALT.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The H you have provided never does a correct wsimulation,
>>>>>>>>>>>>>>> so what it does is actually irrelevent.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Thus no D(D) ever stops running unless an H(D,D) aborts
>>>>>>>>>>>>>>>> the simulation of its input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Nope, since the H(D,D) that D calls DOES abort its
>>>>>>>>>>>>>>> simulation, the H(D,D) simulating this D didn't actually
>>>>>>>>>>>>>>> NEED to abort its simulation,
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You are not paying close enough attention to the exact
>>>>>>>>>>>>>> words that I just said.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If No H(D,D) in the universe ever stops simulating its
>>>>>>>>>>>>>> input then no corresponding executed or simulated D(D) in
>>>>>>>>>>>>>> the universe ever stops running.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> So, you are just PROVING that you are not working on the
>>>>>>>>>>>>> Halting Problem, because that isn't the Halting Problem
>>>>>>>>>>>>> criteria.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> I have already shown that people having a much deeper
>>>>>>>>>>>> understanding than the mere rote memorization of textbooks
>>>>>>>>>>>> understand that my adaptation of the halt status criteria is
>>>>>>>>>>>> equivalent to the conventional notions.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Nope. You are perhaps DECEIVED them into giving assent to a
>>>>>>>>>>> statement whixh appears to match the actual definition but
>>>>>>>>>>> doesn't with your unusual meaning of the words.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> He has written a textbook on the subject and many many papers,
>>>>>>>>>> It is ridiculous to believe that:
>>>>>>>>>> (a) He could be fooled into agreeing with a statement that he
>>>>>>>>>>      did not fully understand.
>>>>>>>>>> AND
>>>>>>>>>> (b) Give me permission to quote his agreement with this
>>>>>>>>>> statement.
>>>>>>>>>>
>>>>>>>>>> I do not believe that Ben believed that he was fooled when Ben
>>>>>>>>>> made the claim that he was fooled. Ben knows better than this.
>>>>>>>>>> Ben simply ran out of options for rebuttal and thus grasped at
>>>>>>>>>> straws.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Right, and he agreed that if H shows that the CORRECT
>>>>>>>>> SIMULATION of its input is non-halting, which is the simulation
>>>>>>>>> by a UTM. H only does a correct simulaition if its simulation
>>>>>>>>> agrees with THAT simulation.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I am only willing to have a mutually honest dialogue.
>>>>>>>>
>>>>>>>
>>>>>>> I'm AM being Honest.
>>>>>>>
>>>>>>>> When I prove that you are incorrect on a point you never
>>>>>>>> acknowledge that I proved that you are incorrect you simply
>>>>>>>> change the subject.
>>>>>>>
>>>>>>> Except that you never have proven me wrong on any major point.
>>>>>>>
>>>>>>>>
>>>>>>>> Acknowledge that he was not fooled and that he most likely fully
>>>>>>>> understood what he agreed to or we cannot move on to the next
>>>>>>>> point.
>>>>>>>>
>>>>>>>
>>>>>>> "Fooled" may be a stronger word then needed. He does not
>>>>>>> interpret the words the way you do. This is in part due to your
>>>>>>> enforced IGNORANCE of the subject.
>>>>>>
>>>>>> Until you acknowledge that you were wrong and he was not fooled at
>>>>>> all we cannot proceed.
>>>>>>
>>>>>
>>>>> No, untill YOU acknowledge that you don't understand the actual
>>>>> meaning of the words, in context, that you have been using, you are
>>>>> just going to continue to show your stupidity.
>>>>>
>>>> OK so you don't want to talk anymore, that is fine with me.
>>>>
>>>
>>>
>>> I will point out that I have nothing to prove, as the Halting Theory,
>>> as proved, is on my side.
>>>
>>> Everything I have said, is just a restating of the accepted Truth.
>>>
>>
>> You refuse to acknowledge any of the points where I am proved to be
>> correct because you (as everyone else here) are only interested in
>> rebuttal, thus have no interest what-so-ever in an honest dialogue.
>>
>> This is intolerable.
>>
>
> Becausse you HAVEN'T proved them, because you just don't understand what
> you are talking about. If you start with incorrect definitions, you just
> can't get anywhere.
>

On 11/30/22 8:34 PM, olcott wrote:
> On 11/30/2022 7:29 PM, Richard Damon wrote:
>> On 11/30/22 8:07 PM, olcott wrote:
>>> On 11/30/2022 7:00 PM, Richard Damon wrote:
>>>> On 11/30/22 7:29 PM, olcott wrote:
>>>>> On 11/30/2022 6:09 PM, Richard Damon wrote:
>>>>>> On 11/30/22 9:38 AM, olcott wrote:
>>>>>>> On 11/30/2022 6:01 AM, Richard Damon wrote:
>>>>>>>> On 11/29/22 11:38 PM, olcott wrote:
>>>>>>>>> On 11/29/2022 10:03 PM, Richard Damon wrote:
>>>>>>>>>> On 11/29/22 10:29 PM, olcott wrote:
>>>>>>>>>>> On 11/29/2022 8:54 PM, Richard Damon wrote:
>>>>>>>>>>>> On 11/29/22 9:30 PM, olcott wrote:
>>>>>>>>>>>>> On 11/29/2022 7:48 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 11/29/22 7:52 PM, olcott wrote:
>>>>>>>>>>>>>>> On 11/29/2022 5:47 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 11/29/22 11:35 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 11/28/2022 11:56 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> void D(void (*x)())
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>>>>>>>    return;
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>    D(D);
>>>>>>>>>>>>>>>>>>    H(D, D);
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The fact that no D(D) ever stops running unless H(D,D)
>>>>>>>>>>>>>>>>>> aborts the simlation of its input conclusively proves
>>>>>>>>>>>>>>>>>> that the input to H(D,D) specifies a non-halting
>>>>>>>>>>>>>>>>>> sequence of configurations.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> [Ignoring stack overflow]
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The above D(D) never stops running unless the H(D,D)
>>>>>>>>>>>>>>>>> that it invokes aborts the simulation of its input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Right, but that is ok, and doesn't make that D
>>>>>>>>>>>>>>>> non-halting by the DEFINITION of what a Halt Decider
>>>>>>>>>>>>>>>> needs to ddcide.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> H(M,x) needs to return Halting if M(x) Halts.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Since D(D) halts, this means that H(D,D) needs to return
>>>>>>>>>>>>>>>> Halting.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Nothing in that ask anything about D using a simulation
>>>>>>>>>>>>>>>> that happens to be aborted.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You are just using wrong definitions.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> D(D) correctly simulated by the above H(D,D) never
>>>>>>>>>>>>>>>>> stops running unless aborted.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Nope, UTM(D,D) which is the DEFINITION of a "Correct
>>>>>>>>>>>>>>>> Simulation" will Halt. Thus the "Correct Simulation" of
>>>>>>>>>>>>>>>> this input WILL HALT.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The H you have provided never does a correct
>>>>>>>>>>>>>>>> wsimulation, so what it does is actually irrelevent.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Thus no D(D) ever stops running unless an H(D,D) aborts
>>>>>>>>>>>>>>>>> the simulation of its input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Nope, since the H(D,D) that D calls DOES abort its
>>>>>>>>>>>>>>>> simulation, the H(D,D) simulating this D didn't actually
>>>>>>>>>>>>>>>> NEED to abort its simulation,
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You are not paying close enough attention to the exact
>>>>>>>>>>>>>>> words that I just said.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If No H(D,D) in the universe ever stops simulating its
>>>>>>>>>>>>>>> input then no corresponding executed or simulated D(D) in
>>>>>>>>>>>>>>> the universe ever stops running.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So, you are just PROVING that you are not working on the
>>>>>>>>>>>>>> Halting Problem, because that isn't the Halting Problem
>>>>>>>>>>>>>> criteria.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> I have already shown that people having a much deeper
>>>>>>>>>>>>> understanding than the mere rote memorization of textbooks
>>>>>>>>>>>>> understand that my adaptation of the halt status criteria
>>>>>>>>>>>>> is equivalent to the conventional notions.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Nope. You are perhaps DECEIVED them into giving assent to a
>>>>>>>>>>>> statement whixh appears to match the actual definition but
>>>>>>>>>>>> doesn't with your unusual meaning of the words.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> He has written a textbook on the subject and many many papers,
>>>>>>>>>>> It is ridiculous to believe that:
>>>>>>>>>>> (a) He could be fooled into agreeing with a statement that he
>>>>>>>>>>>      did not fully understand.
>>>>>>>>>>> AND
>>>>>>>>>>> (b) Give me permission to quote his agreement with this
>>>>>>>>>>> statement.
>>>>>>>>>>>
>>>>>>>>>>> I do not believe that Ben believed that he was fooled when
>>>>>>>>>>> Ben made the claim that he was fooled. Ben knows better than
>>>>>>>>>>> this. Ben simply ran out of options for rebuttal and thus
>>>>>>>>>>> grasped at straws.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Right, and he agreed that if H shows that the CORRECT
>>>>>>>>>> SIMULATION of its input is non-halting, which is the
>>>>>>>>>> simulation by a UTM. H only does a correct simulaition if its
>>>>>>>>>> simulation agrees with THAT simulation.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I am only willing to have a mutually honest dialogue.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I'm AM being Honest.
>>>>>>>>
>>>>>>>>> When I prove that you are incorrect on a point you never
>>>>>>>>> acknowledge that I proved that you are incorrect you simply
>>>>>>>>> change the subject.
>>>>>>>>
>>>>>>>> Except that you never have proven me wrong on any major point.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> Acknowledge that he was not fooled and that he most likely
>>>>>>>>> fully understood what he agreed to or we cannot move on to the
>>>>>>>>> next point.
>>>>>>>>>
>>>>>>>>
>>>>>>>> "Fooled" may be a stronger word then needed. He does not
>>>>>>>> interpret the words the way you do. This is in part due to your
>>>>>>>> enforced IGNORANCE of the subject.
>>>>>>>
>>>>>>> Until you acknowledge that you were wrong and he was not fooled
>>>>>>> at all we cannot proceed.
>>>>>>>
>>>>>>
>>>>>> No, untill YOU acknowledge that you don't understand the actual
>>>>>> meaning of the words, in context, that you have been using, you
>>>>>> are just going to continue to show your stupidity.
>>>>>>
>>>>> OK so you don't want to talk anymore, that is fine with me.
>>>>>
>>>>
>>>>
>>>> I will point out that I have nothing to prove, as the Halting
>>>> Theory, as proved, is on my side.
>>>>
>>>> Everything I have said, is just a restating of the accepted Truth.
>>>>
>>>
>>> You refuse to acknowledge any of the points where I am proved to be
>>> correct because you (as everyone else here) are only interested in
>>> rebuttal, thus have no interest what-so-ever in an honest dialogue.
>>>
>>> This is intolerable.
>>>
>>
>> Becausse you HAVEN'T proved them, because you just don't understand
>> what you are talking about. If you start with incorrect definitions,
>> you just can't get anywhere.
>>
>
> Until you acknowledge that you were wrong and he was never fooled you
> will get no more words from me.
>

On 11/30/2022 8:08 PM, Richard Damon wrote:
> On 11/30/22 8:34 PM, olcott wrote:
>> On 11/30/2022 7:29 PM, Richard Damon wrote:
>>> On 11/30/22 8:07 PM, olcott wrote:
>>>> On 11/30/2022 7:00 PM, Richard Damon wrote:
>>>>> On 11/30/22 7:29 PM, olcott wrote:
>>>>>> On 11/30/2022 6:09 PM, Richard Damon wrote:
>>>>>>> On 11/30/22 9:38 AM, olcott wrote:
>>>>>>>> On 11/30/2022 6:01 AM, Richard Damon wrote:
>>>>>>>>> On 11/29/22 11:38 PM, olcott wrote:
>>>>>>>>>> On 11/29/2022 10:03 PM, Richard Damon wrote:
>>>>>>>>>>> On 11/29/22 10:29 PM, olcott wrote:
>>>>>>>>>>>> On 11/29/2022 8:54 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 11/29/22 9:30 PM, olcott wrote:
>>>>>>>>>>>>>> On 11/29/2022 7:48 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 11/29/22 7:52 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 11/29/2022 5:47 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 11/29/22 11:35 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 11/28/2022 11:56 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> void D(void (*x)())
>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>    return;
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>    D(D);
>>>>>>>>>>>>>>>>>>>    H(D, D);
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The fact that no D(D) ever stops running unless
>>>>>>>>>>>>>>>>>>> H(D,D) aborts the simlation of its input conclusively
>>>>>>>>>>>>>>>>>>> proves that the input to H(D,D) specifies a
>>>>>>>>>>>>>>>>>>> non-halting sequence of configurations.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> [Ignoring stack overflow]
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The above D(D) never stops running unless the H(D,D)
>>>>>>>>>>>>>>>>>> that it invokes aborts the simulation of its input.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Right, but that is ok, and doesn't make that D
>>>>>>>>>>>>>>>>> non-halting by the DEFINITION of what a Halt Decider
>>>>>>>>>>>>>>>>> needs to ddcide.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> H(M,x) needs to return Halting if M(x) Halts.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Since D(D) halts, this means that H(D,D) needs to
>>>>>>>>>>>>>>>>> return Halting.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Nothing in that ask anything about D using a simulation
>>>>>>>>>>>>>>>>> that happens to be aborted.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You are just using wrong definitions.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> D(D) correctly simulated by the above H(D,D) never
>>>>>>>>>>>>>>>>>> stops running unless aborted.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Nope, UTM(D,D) which is the DEFINITION of a "Correct
>>>>>>>>>>>>>>>>> Simulation" will Halt. Thus the "Correct Simulation" of
>>>>>>>>>>>>>>>>> this input WILL HALT.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The H you have provided never does a correct
>>>>>>>>>>>>>>>>> wsimulation, so what it does is actually irrelevent.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Thus no D(D) ever stops running unless an H(D,D)
>>>>>>>>>>>>>>>>>> aborts the simulation of its input.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Nope, since the H(D,D) that D calls DOES abort its
>>>>>>>>>>>>>>>>> simulation, the H(D,D) simulating this D didn't
>>>>>>>>>>>>>>>>> actually NEED to abort its simulation,
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You are not paying close enough attention to the exact
>>>>>>>>>>>>>>>> words that I just said.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If No H(D,D) in the universe ever stops simulating its
>>>>>>>>>>>>>>>> input then no corresponding executed or simulated D(D)
>>>>>>>>>>>>>>>> in the universe ever stops running.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> So, you are just PROVING that you are not working on the
>>>>>>>>>>>>>>> Halting Problem, because that isn't the Halting Problem
>>>>>>>>>>>>>>> criteria.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I have already shown that people having a much deeper
>>>>>>>>>>>>>> understanding than the mere rote memorization of textbooks
>>>>>>>>>>>>>> understand that my adaptation of the halt status criteria
>>>>>>>>>>>>>> is equivalent to the conventional notions.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope. You are perhaps DECEIVED them into giving assent to a
>>>>>>>>>>>>> statement whixh appears to match the actual definition but
>>>>>>>>>>>>> doesn't with your unusual meaning of the words.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> He has written a textbook on the subject and many many papers,
>>>>>>>>>>>> It is ridiculous to believe that:
>>>>>>>>>>>> (a) He could be fooled into agreeing with a statement that he
>>>>>>>>>>>>      did not fully understand.
>>>>>>>>>>>> AND
>>>>>>>>>>>> (b) Give me permission to quote his agreement with this
>>>>>>>>>>>> statement.
>>>>>>>>>>>>
>>>>>>>>>>>> I do not believe that Ben believed that he was fooled when
>>>>>>>>>>>> Ben made the claim that he was fooled. Ben knows better than
>>>>>>>>>>>> this. Ben simply ran out of options for rebuttal and thus
>>>>>>>>>>>> grasped at straws.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Right, and he agreed that if H shows that the CORRECT
>>>>>>>>>>> SIMULATION of its input is non-halting, which is the
>>>>>>>>>>> simulation by a UTM. H only does a correct simulaition if its
>>>>>>>>>>> simulation agrees with THAT simulation.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I am only willing to have a mutually honest dialogue.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I'm AM being Honest.
>>>>>>>>>
>>>>>>>>>> When I prove that you are incorrect on a point you never
>>>>>>>>>> acknowledge that I proved that you are incorrect you simply
>>>>>>>>>> change the subject.
>>>>>>>>>
>>>>>>>>> Except that you never have proven me wrong on any major point.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Acknowledge that he was not fooled and that he most likely
>>>>>>>>>> fully understood what he agreed to or we cannot move on to the
>>>>>>>>>> next point.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> "Fooled" may be a stronger word then needed. He does not
>>>>>>>>> interpret the words the way you do. This is in part due to your
>>>>>>>>> enforced IGNORANCE of the subject.
>>>>>>>>
>>>>>>>> Until you acknowledge that you were wrong and he was not fooled
>>>>>>>> at all we cannot proceed.
>>>>>>>>
>>>>>>>
>>>>>>> No, untill YOU acknowledge that you don't understand the actual
>>>>>>> meaning of the words, in context, that you have been using, you
>>>>>>> are just going to continue to show your stupidity.
>>>>>>>
>>>>>> OK so you don't want to talk anymore, that is fine with me.
>>>>>>
>>>>>
>>>>>
>>>>> I will point out that I have nothing to prove, as the Halting
>>>>> Theory, as proved, is on my side.
>>>>>
>>>>> Everything I have said, is just a restating of the accepted Truth.
>>>>>
>>>>
>>>> You refuse to acknowledge any of the points where I am proved to be
>>>> correct because you (as everyone else here) are only interested in
>>>> rebuttal, thus have no interest what-so-ever in an honest dialogue.
>>>>
>>>> This is intolerable.
>>>>
>>>
>>> Becausse you HAVEN'T proved them, because you just don't understand
>>> what you are talking about. If you start with incorrect definitions,
>>> you just can't get anywhere.
>>>
>>
>> Until you acknowledge that you were wrong and he was never fooled you
>> will get no more words from me.
>>
>
> So, you aren't reading?
>
> I ppointed out that "fooled" may be not quite the right word, as it
> isn't so much you "tricked" him into agreeing to a false statement, but
> that you don't understand the statement that you wrote, because you
> don't understand the basics of the language of the field.
>

On 12/1/22 12:43 AM, olcott wrote:
> On 11/30/2022 8:08 PM, Richard Damon wrote:
>> On 11/30/22 8:34 PM, olcott wrote:
>>> On 11/30/2022 7:29 PM, Richard Damon wrote:
>>>> On 11/30/22 8:07 PM, olcott wrote:
>>>>> On 11/30/2022 7:00 PM, Richard Damon wrote:
>>>>>> On 11/30/22 7:29 PM, olcott wrote:
>>>>>>> On 11/30/2022 6:09 PM, Richard Damon wrote:
>>>>>>>> On 11/30/22 9:38 AM, olcott wrote:
>>>>>>>>> On 11/30/2022 6:01 AM, Richard Damon wrote:
>>>>>>>>>> On 11/29/22 11:38 PM, olcott wrote:
>>>>>>>>>>> On 11/29/2022 10:03 PM, Richard Damon wrote:
>>>>>>>>>>>> On 11/29/22 10:29 PM, olcott wrote:
>>>>>>>>>>>>> On 11/29/2022 8:54 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 11/29/22 9:30 PM, olcott wrote:
>>>>>>>>>>>>>>> On 11/29/2022 7:48 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 11/29/22 7:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 11/29/2022 5:47 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 11/29/22 11:35 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 11/28/2022 11:56 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> void D(void (*x)())
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>    return;
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>    D(D);
>>>>>>>>>>>>>>>>>>>>    H(D, D);
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The fact that no D(D) ever stops running unless
>>>>>>>>>>>>>>>>>>>> H(D,D) aborts the simlation of its input
>>>>>>>>>>>>>>>>>>>> conclusively proves that the input to H(D,D)
>>>>>>>>>>>>>>>>>>>> specifies a non-halting sequence of configurations.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> [Ignoring stack overflow]
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The above D(D) never stops running unless the H(D,D)
>>>>>>>>>>>>>>>>>>> that it invokes aborts the simulation of its input.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Right, but that is ok, and doesn't make that D
>>>>>>>>>>>>>>>>>> non-halting by the DEFINITION of what a Halt Decider
>>>>>>>>>>>>>>>>>> needs to ddcide.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> H(M,x) needs to return Halting if M(x) Halts.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Since D(D) halts, this means that H(D,D) needs to
>>>>>>>>>>>>>>>>>> return Halting.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Nothing in that ask anything about D using a
>>>>>>>>>>>>>>>>>> simulation that happens to be aborted.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You are just using wrong definitions.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> D(D) correctly simulated by the above H(D,D) never
>>>>>>>>>>>>>>>>>>> stops running unless aborted.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Nope, UTM(D,D) which is the DEFINITION of a "Correct
>>>>>>>>>>>>>>>>>> Simulation" will Halt. Thus the "Correct Simulation"
>>>>>>>>>>>>>>>>>> of this input WILL HALT.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The H you have provided never does a correct
>>>>>>>>>>>>>>>>>> wsimulation, so what it does is actually irrelevent.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Thus no D(D) ever stops running unless an H(D,D)
>>>>>>>>>>>>>>>>>>> aborts the simulation of its input.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Nope, since the H(D,D) that D calls DOES abort its
>>>>>>>>>>>>>>>>>> simulation, the H(D,D) simulating this D didn't
>>>>>>>>>>>>>>>>>> actually NEED to abort its simulation,
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You are not paying close enough attention to the exact
>>>>>>>>>>>>>>>>> words that I just said.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If No H(D,D) in the universe ever stops simulating its
>>>>>>>>>>>>>>>>> input then no corresponding executed or simulated D(D)
>>>>>>>>>>>>>>>>> in the universe ever stops running.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So, you are just PROVING that you are not working on the
>>>>>>>>>>>>>>>> Halting Problem, because that isn't the Halting Problem
>>>>>>>>>>>>>>>> criteria.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I have already shown that people having a much deeper
>>>>>>>>>>>>>>> understanding than the mere rote memorization of
>>>>>>>>>>>>>>> textbooks understand that my adaptation of the halt
>>>>>>>>>>>>>>> status criteria is equivalent to the conventional notions.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Nope. You are perhaps DECEIVED them into giving assent to
>>>>>>>>>>>>>> a statement whixh appears to match the actual definition
>>>>>>>>>>>>>> but doesn't with your unusual meaning of the words.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> He has written a textbook on the subject and many many papers,
>>>>>>>>>>>>> It is ridiculous to believe that:
>>>>>>>>>>>>> (a) He could be fooled into agreeing with a statement that he
>>>>>>>>>>>>>      did not fully understand.
>>>>>>>>>>>>> AND
>>>>>>>>>>>>> (b) Give me permission to quote his agreement with this
>>>>>>>>>>>>> statement.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I do not believe that Ben believed that he was fooled when
>>>>>>>>>>>>> Ben made the claim that he was fooled. Ben knows better
>>>>>>>>>>>>> than this. Ben simply ran out of options for rebuttal and
>>>>>>>>>>>>> thus grasped at straws.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Right, and he agreed that if H shows that the CORRECT
>>>>>>>>>>>> SIMULATION of its input is non-halting, which is the
>>>>>>>>>>>> simulation by a UTM. H only does a correct simulaition if
>>>>>>>>>>>> its simulation agrees with THAT simulation.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> I am only willing to have a mutually honest dialogue.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I'm AM being Honest.
>>>>>>>>>>
>>>>>>>>>>> When I prove that you are incorrect on a point you never
>>>>>>>>>>> acknowledge that I proved that you are incorrect you simply
>>>>>>>>>>> change the subject.
>>>>>>>>>>
>>>>>>>>>> Except that you never have proven me wrong on any major point.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Acknowledge that he was not fooled and that he most likely
>>>>>>>>>>> fully understood what he agreed to or we cannot move on to
>>>>>>>>>>> the next point.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> "Fooled" may be a stronger word then needed. He does not
>>>>>>>>>> interpret the words the way you do. This is in part due to
>>>>>>>>>> your enforced IGNORANCE of the subject.
>>>>>>>>>
>>>>>>>>> Until you acknowledge that you were wrong and he was not fooled
>>>>>>>>> at all we cannot proceed.
>>>>>>>>>
>>>>>>>>
>>>>>>>> No, untill YOU acknowledge that you don't understand the actual
>>>>>>>> meaning of the words, in context, that you have been using, you
>>>>>>>> are just going to continue to show your stupidity.
>>>>>>>>
>>>>>>> OK so you don't want to talk anymore, that is fine with me.
>>>>>>>
>>>>>>
>>>>>>
>>>>>> I will point out that I have nothing to prove, as the Halting
>>>>>> Theory, as proved, is on my side.
>>>>>>
>>>>>> Everything I have said, is just a restating of the accepted Truth.
>>>>>>
>>>>>
>>>>> You refuse to acknowledge any of the points where I am proved to be
>>>>> correct because you (as everyone else here) are only interested in
>>>>> rebuttal, thus have no interest what-so-ever in an honest dialogue.
>>>>>
>>>>> This is intolerable.
>>>>>
>>>>
>>>> Becausse you HAVEN'T proved them, because you just don't understand
>>>> what you are talking about. If you start with incorrect definitions,
>>>> you just can't get anywhere.
>>>>
>>>
>>> Until you acknowledge that you were wrong and he was never fooled you
>>> will get no more words from me.
>>>
>>
>> So, you aren't reading?
>>
>> I ppointed out that "fooled" may be not quite the right word, as it
>> isn't so much you "tricked" him into agreeing to a false statement,
>> but that you don't understand the statement that you wrote, because
>> you don't understand the basics of the language of the field.
>>
>
> You must specifically admit that your were wrong.

On 12/1/2022 5:46 AM, Richard Damon wrote:
> On 12/1/22 12:43 AM, olcott wrote:
>> On 11/30/2022 8:08 PM, Richard Damon wrote:
>>> On 11/30/22 8:34 PM, olcott wrote:
>>>> On 11/30/2022 7:29 PM, Richard Damon wrote:
>>>>> On 11/30/22 8:07 PM, olcott wrote:
>>>>>> On 11/30/2022 7:00 PM, Richard Damon wrote:
>>>>>>> On 11/30/22 7:29 PM, olcott wrote:
>>>>>>>> On 11/30/2022 6:09 PM, Richard Damon wrote:
>>>>>>>>> On 11/30/22 9:38 AM, olcott wrote:
>>>>>>>>>> On 11/30/2022 6:01 AM, Richard Damon wrote:
>>>>>>>>>>> On 11/29/22 11:38 PM, olcott wrote:
>>>>>>>>>>>> On 11/29/2022 10:03 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 11/29/22 10:29 PM, olcott wrote:
>>>>>>>>>>>>>> On 11/29/2022 8:54 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 11/29/22 9:30 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 11/29/2022 7:48 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 11/29/22 7:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 11/29/2022 5:47 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 11/29/22 11:35 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 11/28/2022 11:56 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> void D(void (*x)())
>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>    return;
>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>    D(D);
>>>>>>>>>>>>>>>>>>>>>    H(D, D);
>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The fact that no D(D) ever stops running unless
>>>>>>>>>>>>>>>>>>>>> H(D,D) aborts the simlation of its input
>>>>>>>>>>>>>>>>>>>>> conclusively proves that the input to H(D,D)
>>>>>>>>>>>>>>>>>>>>> specifies a non-halting sequence of configurations.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> [Ignoring stack overflow]
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The above D(D) never stops running unless the H(D,D)
>>>>>>>>>>>>>>>>>>>> that it invokes aborts the simulation of its input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Right, but that is ok, and doesn't make that D
>>>>>>>>>>>>>>>>>>> non-halting by the DEFINITION of what a Halt Decider
>>>>>>>>>>>>>>>>>>> needs to ddcide.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> H(M,x) needs to return Halting if M(x) Halts.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Since D(D) halts, this means that H(D,D) needs to
>>>>>>>>>>>>>>>>>>> return Halting.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Nothing in that ask anything about D using a
>>>>>>>>>>>>>>>>>>> simulation that happens to be aborted.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You are just using wrong definitions.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> D(D) correctly simulated by the above H(D,D) never
>>>>>>>>>>>>>>>>>>>> stops running unless aborted.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Nope, UTM(D,D) which is the DEFINITION of a "Correct
>>>>>>>>>>>>>>>>>>> Simulation" will Halt. Thus the "Correct Simulation"
>>>>>>>>>>>>>>>>>>> of this input WILL HALT.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The H you have provided never does a correct
>>>>>>>>>>>>>>>>>>> wsimulation, so what it does is actually irrelevent.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Thus no D(D) ever stops running unless an H(D,D)
>>>>>>>>>>>>>>>>>>>> aborts the simulation of its input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Nope, since the H(D,D) that D calls DOES abort its
>>>>>>>>>>>>>>>>>>> simulation, the H(D,D) simulating this D didn't
>>>>>>>>>>>>>>>>>>> actually NEED to abort its simulation,
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You are not paying close enough attention to the exact
>>>>>>>>>>>>>>>>>> words that I just said.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If No H(D,D) in the universe ever stops simulating its
>>>>>>>>>>>>>>>>>> input then no corresponding executed or simulated D(D)
>>>>>>>>>>>>>>>>>> in the universe ever stops running.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> So, you are just PROVING that you are not working on
>>>>>>>>>>>>>>>>> the Halting Problem, because that isn't the Halting
>>>>>>>>>>>>>>>>> Problem criteria.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I have already shown that people having a much deeper
>>>>>>>>>>>>>>>> understanding than the mere rote memorization of
>>>>>>>>>>>>>>>> textbooks understand that my adaptation of the halt
>>>>>>>>>>>>>>>> status criteria is equivalent to the conventional notions.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Nope. You are perhaps DECEIVED them into giving assent to
>>>>>>>>>>>>>>> a statement whixh appears to match the actual definition
>>>>>>>>>>>>>>> but doesn't with your unusual meaning of the words.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> He has written a textbook on the subject and many many
>>>>>>>>>>>>>> papers,
>>>>>>>>>>>>>> It is ridiculous to believe that:
>>>>>>>>>>>>>> (a) He could be fooled into agreeing with a statement that he
>>>>>>>>>>>>>>      did not fully understand.
>>>>>>>>>>>>>> AND
>>>>>>>>>>>>>> (b) Give me permission to quote his agreement with this
>>>>>>>>>>>>>> statement.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I do not believe that Ben believed that he was fooled when
>>>>>>>>>>>>>> Ben made the claim that he was fooled. Ben knows better
>>>>>>>>>>>>>> than this. Ben simply ran out of options for rebuttal and
>>>>>>>>>>>>>> thus grasped at straws.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Right, and he agreed that if H shows that the CORRECT
>>>>>>>>>>>>> SIMULATION of its input is non-halting, which is the
>>>>>>>>>>>>> simulation by a UTM. H only does a correct simulaition if
>>>>>>>>>>>>> its simulation agrees with THAT simulation.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> I am only willing to have a mutually honest dialogue.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> I'm AM being Honest.
>>>>>>>>>>>
>>>>>>>>>>>> When I prove that you are incorrect on a point you never
>>>>>>>>>>>> acknowledge that I proved that you are incorrect you simply
>>>>>>>>>>>> change the subject.
>>>>>>>>>>>
>>>>>>>>>>> Except that you never have proven me wrong on any major point.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Acknowledge that he was not fooled and that he most likely
>>>>>>>>>>>> fully understood what he agreed to or we cannot move on to
>>>>>>>>>>>> the next point.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> "Fooled" may be a stronger word then needed. He does not
>>>>>>>>>>> interpret the words the way you do. This is in part due to
>>>>>>>>>>> your enforced IGNORANCE of the subject.
>>>>>>>>>>
>>>>>>>>>> Until you acknowledge that you were wrong and he was not
>>>>>>>>>> fooled at all we cannot proceed.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> No, untill YOU acknowledge that you don't understand the actual
>>>>>>>>> meaning of the words, in context, that you have been using, you
>>>>>>>>> are just going to continue to show your stupidity.
>>>>>>>>>
>>>>>>>> OK so you don't want to talk anymore, that is fine with me.
>>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> I will point out that I have nothing to prove, as the Halting
>>>>>>> Theory, as proved, is on my side.
>>>>>>>
>>>>>>> Everything I have said, is just a restating of the accepted Truth.
>>>>>>>
>>>>>>
>>>>>> You refuse to acknowledge any of the points where I am proved to
>>>>>> be correct because you (as everyone else here) are only interested
>>>>>> in rebuttal, thus have no interest what-so-ever in an honest
>>>>>> dialogue.
>>>>>>
>>>>>> This is intolerable.
>>>>>>
>>>>>
>>>>> Becausse you HAVEN'T proved them, because you just don't understand
>>>>> what you are talking about. If you start with incorrect
>>>>> definitions, you just can't get anywhere.
>>>>>
>>>>
>>>> Until you acknowledge that you were wrong and he was never fooled
>>>> you will get no more words from me.
>>>>
>>>
>>> So, you aren't reading?
>>>
>>> I ppointed out that "fooled" may be not quite the right word, as it
>>> isn't so much you "tricked" him into agreeing to a false statement,
>>> but that you don't understand the statement that you wrote, because
>>> you don't understand the basics of the language of the field.
>>>
>>
>> You must specifically admit that your were wrong.
>
>
> Since I am not, that won't happen.
>

On 12/1/22 10:40 AM, olcott wrote:
> On 12/1/2022 5:46 AM, Richard Damon wrote:
>> On 12/1/22 12:43 AM, olcott wrote:
>>> On 11/30/2022 8:08 PM, Richard Damon wrote:
>>>> On 11/30/22 8:34 PM, olcott wrote:
>>>>> On 11/30/2022 7:29 PM, Richard Damon wrote:
>>>>>> On 11/30/22 8:07 PM, olcott wrote:
>>>>>>> On 11/30/2022 7:00 PM, Richard Damon wrote:
>>>>>>>> On 11/30/22 7:29 PM, olcott wrote:
>>>>>>>>> On 11/30/2022 6:09 PM, Richard Damon wrote:
>>>>>>>>>> On 11/30/22 9:38 AM, olcott wrote:
>>>>>>>>>>> On 11/30/2022 6:01 AM, Richard Damon wrote:
>>>>>>>>>>>> On 11/29/22 11:38 PM, olcott wrote:
>>>>>>>>>>>>> On 11/29/2022 10:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 11/29/22 10:29 PM, olcott wrote:
>>>>>>>>>>>>>>> On 11/29/2022 8:54 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 11/29/22 9:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 11/29/2022 7:48 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 11/29/22 7:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 11/29/2022 5:47 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 11/29/22 11:35 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 11/28/2022 11:56 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> void D(void (*x)())
>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>    return;
>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>    D(D);
>>>>>>>>>>>>>>>>>>>>>>    H(D, D);
>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The fact that no D(D) ever stops running unless
>>>>>>>>>>>>>>>>>>>>>> H(D,D) aborts the simlation of its input
>>>>>>>>>>>>>>>>>>>>>> conclusively proves that the input to H(D,D)
>>>>>>>>>>>>>>>>>>>>>> specifies a non-halting sequence of configurations.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> [Ignoring stack overflow]
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The above D(D) never stops running unless the
>>>>>>>>>>>>>>>>>>>>> H(D,D) that it invokes aborts the simulation of its
>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Right, but that is ok, and doesn't make that D
>>>>>>>>>>>>>>>>>>>> non-halting by the DEFINITION of what a Halt Decider
>>>>>>>>>>>>>>>>>>>> needs to ddcide.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> H(M,x) needs to return Halting if M(x) Halts.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Since D(D) halts, this means that H(D,D) needs to
>>>>>>>>>>>>>>>>>>>> return Halting.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Nothing in that ask anything about D using a
>>>>>>>>>>>>>>>>>>>> simulation that happens to be aborted.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You are just using wrong definitions.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> D(D) correctly simulated by the above H(D,D) never
>>>>>>>>>>>>>>>>>>>>> stops running unless aborted.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Nope, UTM(D,D) which is the DEFINITION of a "Correct
>>>>>>>>>>>>>>>>>>>> Simulation" will Halt. Thus the "Correct Simulation"
>>>>>>>>>>>>>>>>>>>> of this input WILL HALT.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The H you have provided never does a correct
>>>>>>>>>>>>>>>>>>>> wsimulation, so what it does is actually irrelevent.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Thus no D(D) ever stops running unless an H(D,D)
>>>>>>>>>>>>>>>>>>>>> aborts the simulation of its input.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Nope, since the H(D,D) that D calls DOES abort its
>>>>>>>>>>>>>>>>>>>> simulation, the H(D,D) simulating this D didn't
>>>>>>>>>>>>>>>>>>>> actually NEED to abort its simulation,
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You are not paying close enough attention to the
>>>>>>>>>>>>>>>>>>> exact words that I just said.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If No H(D,D) in the universe ever stops simulating
>>>>>>>>>>>>>>>>>>> its input then no corresponding executed or simulated
>>>>>>>>>>>>>>>>>>> D(D) in the universe ever stops running.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> So, you are just PROVING that you are not working on
>>>>>>>>>>>>>>>>>> the Halting Problem, because that isn't the Halting
>>>>>>>>>>>>>>>>>> Problem criteria.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I have already shown that people having a much deeper
>>>>>>>>>>>>>>>>> understanding than the mere rote memorization of
>>>>>>>>>>>>>>>>> textbooks understand that my adaptation of the halt
>>>>>>>>>>>>>>>>> status criteria is equivalent to the conventional notions.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Nope. You are perhaps DECEIVED them into giving assent
>>>>>>>>>>>>>>>> to a statement whixh appears to match the actual
>>>>>>>>>>>>>>>> definition but doesn't with your unusual meaning of the
>>>>>>>>>>>>>>>> words.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> He has written a textbook on the subject and many many
>>>>>>>>>>>>>>> papers,
>>>>>>>>>>>>>>> It is ridiculous to believe that:
>>>>>>>>>>>>>>> (a) He could be fooled into agreeing with a statement
>>>>>>>>>>>>>>> that he
>>>>>>>>>>>>>>>      did not fully understand.
>>>>>>>>>>>>>>> AND
>>>>>>>>>>>>>>> (b) Give me permission to quote his agreement with this
>>>>>>>>>>>>>>> statement.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I do not believe that Ben believed that he was fooled
>>>>>>>>>>>>>>> when Ben made the claim that he was fooled. Ben knows
>>>>>>>>>>>>>>> better than this. Ben simply ran out of options for
>>>>>>>>>>>>>>> rebuttal and thus grasped at straws.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Right, and he agreed that if H shows that the CORRECT
>>>>>>>>>>>>>> SIMULATION of its input is non-halting, which is the
>>>>>>>>>>>>>> simulation by a UTM. H only does a correct simulaition if
>>>>>>>>>>>>>> its simulation agrees with THAT simulation.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> I am only willing to have a mutually honest dialogue.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> I'm AM being Honest.
>>>>>>>>>>>>
>>>>>>>>>>>>> When I prove that you are incorrect on a point you never
>>>>>>>>>>>>> acknowledge that I proved that you are incorrect you simply
>>>>>>>>>>>>> change the subject.
>>>>>>>>>>>>
>>>>>>>>>>>> Except that you never have proven me wrong on any major point.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Acknowledge that he was not fooled and that he most likely
>>>>>>>>>>>>> fully understood what he agreed to or we cannot move on to
>>>>>>>>>>>>> the next point.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> "Fooled" may be a stronger word then needed. He does not
>>>>>>>>>>>> interpret the words the way you do. This is in part due to
>>>>>>>>>>>> your enforced IGNORANCE of the subject.
>>>>>>>>>>>
>>>>>>>>>>> Until you acknowledge that you were wrong and he was not
>>>>>>>>>>> fooled at all we cannot proceed.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> No, untill YOU acknowledge that you don't understand the
>>>>>>>>>> actual meaning of the words, in context, that you have been
>>>>>>>>>> using, you are just going to continue to show your stupidity.
>>>>>>>>>>
>>>>>>>>> OK so you don't want to talk anymore, that is fine with me.
>>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> I will point out that I have nothing to prove, as the Halting
>>>>>>>> Theory, as proved, is on my side.
>>>>>>>>
>>>>>>>> Everything I have said, is just a restating of the accepted Truth.
>>>>>>>>
>>>>>>>
>>>>>>> You refuse to acknowledge any of the points where I am proved to
>>>>>>> be correct because you (as everyone else here) are only
>>>>>>> interested in rebuttal, thus have no interest what-so-ever in an
>>>>>>> honest dialogue.
>>>>>>>
>>>>>>> This is intolerable.
>>>>>>>
>>>>>>
>>>>>> Becausse you HAVEN'T proved them, because you just don't
>>>>>> understand what you are talking about. If you start with incorrect
>>>>>> definitions, you just can't get anywhere.
>>>>>>
>>>>>
>>>>> Until you acknowledge that you were wrong and he was never fooled
>>>>> you will get no more words from me.
>>>>>
>>>>
>>>> So, you aren't reading?
>>>>
>>>> I ppointed out that "fooled" may be not quite the right word, as it
>>>> isn't so much you "tricked" him into agreeing to a false statement,
>>>> but that you don't understand the statement that you wrote, because
>>>> you don't understand the basics of the language of the field.
>>>>
>>>
>>> You must specifically admit that your were wrong.
>>
>>
>> Since I am not, that won't happen.
>>
>
> Acknowledge that [you were wrong when you said] he was fooled or we
> cannot move on to the next point.
>
> You must say this words: "I was wrong when I said he was fooled."