On 12/1/2022 5:34 PM, Richard Damon wrote:
> 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."
>
> No, because in a real sense he was, because you use a deceptive statment
> which you take to mean something that he doesn't.
>
Even if this is true [AND IT IS NOT TRUE**] that would not be any
evidence at all that he was deceived. Because you already know this you
have sufficiently proven that you are not interested in an honest dialogue.

On 12/1/22 7:43 PM, olcott wrote:
> On 12/1/2022 5:34 PM, Richard Damon wrote:
>> 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."
>>
>> No, because in a real sense he was, because you use a deceptive
>> statment which you take to mean something that he doesn't.
>>
> Even if this is true [AND IT IS NOT TRUE**] that would not be any
> evidence at all that he was deceived. Because you already know this you
> have sufficiently proven that you are not interested in an honest dialogue.

On 12/1/2022 8:43 PM, Richard Damon wrote:
> On 12/1/22 7:43 PM, olcott wrote:
>> On 12/1/2022 5:34 PM, Richard Damon wrote:
>>> 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."
>>>
>>> No, because in a real sense he was, because you use a deceptive
>>> statment which you take to mean something that he doesn't.
>>>
>> Even if this is true [AND IT IS NOT TRUE**] that would not be any
>> evidence at all that he was deceived. Because you already know this
>> you have sufficiently proven that you are not interested in an honest
>> dialogue.
>
> No, the fact that you refuse to accept the truth shows that you do not
> understand what truth IS.
>
> You are showing your STUPIDITY.
>

On 12/1/22 9:51 PM, olcott wrote:
> On 12/1/2022 8:43 PM, Richard Damon wrote:
>> On 12/1/22 7:43 PM, olcott wrote:
>>> On 12/1/2022 5:34 PM, Richard Damon wrote:
>>>> 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."
>>>>
>>>> No, because in a real sense he was, because you use a deceptive
>>>> statment which you take to mean something that he doesn't.
>>>>
>>> Even if this is true [AND IT IS NOT TRUE**] that would not be any
>>> evidence at all that he was deceived. Because you already know this
>>> you have sufficiently proven that you are not interested in an honest
>>> dialogue.
>>
>> No, the fact that you refuse to accept the truth shows that you do not
>> understand what truth IS.
>>
>> You are showing your STUPIDITY.
>>
>
> What does this have to do with me fooling him?
>
> You were wrong when you said he was fooled and you failed to flatly
> admit that you were wrong thus proving that honesty is not your policy.
>
>

On Friday, 2 December 2022 at 04:51:50 UTC+2, olcott wrote:
> blah blah blah

Olcott, how long did your doctor give you?

Just trying to figure out when the spam stops.

On Friday, 2 December 2022 at 05:38:14 UTC+2, richar...@gmail.com wrote:
> You have destroyed your reputation, and will be remembered for being the
> ignoramous you have showed yourself to be.

Hey moron! You still haven't figured out that the entire debate is literally about assigning meaning to function outputs?

ANY function (human; or a C program) will produce whatever output it produces.

Olcott is trolling you hard on the fact that you have (somehow) decided that the answer is "correct"; or "incorrect". As if you have an authoritative decision procedure on "correctness"

On Friday, 2 December 2022 at 04:43:11 UTC+2, richar...@gmail.com wrote:
> Right, and in compuation theory it means a simultion that exactly
> reproduces the results of a (complete) direct execution of the program
> being simulated.

So what is the complete result of the direct execution of this Ruby program?

def f:
loop {}
return 1
end

Whatever answer you give to the above: please provide the algorithm which obtained the answer.
And specifically - if you your answer is "the program doesn't halt" - please provide the halting decider which produced the answer.

On 12/2/22 3:51 AM, Skep Dick wrote:
> On Friday, 2 December 2022 at 05:38:14 UTC+2, richar...@gmail.com wrote:
>> You have destroyed your reputation, and will be remembered for being the
>> ignoramous you have showed yourself to be.
>
> Hey moron! You still haven't figured out that the entire debate is literally about assigning meaning to function outputs?

The problem is we are in a domain that is fully defined on this point,
and the possible answer of H have strictly defined meanings.

Olcott seem to think that this specific H can sometimes give one answer
and sometimes another.

>
> ANY function (human; or a C program) will produce whatever output it produces.

Right, and the answer that H produces doesn't match the answer required
by the problem statement, so is wrong.

>
> Olcott is trolling you hard on the fact that you have (somehow) decided that the answer is "correct"; or "incorrect". As if you have an authoritative decision procedure on "correctness"
>

Because the answer from a Halt Decider IS either correct or incorrect
since it IS a pure "Binary" decision, that always has a answer.

On Friday, 2 December 2022 at 14:28:01 UTC+2, richar...@gmail.com wrote:
> The problem is we are in a domain that is fully defined on this point,
> and the possible answer of H have strictly defined meanings.
If that were true then your formal system is necessarily complete.

> Olcott seem to think that this specific H can sometimes give one answer
> and sometimes another.
It's not a matter of what anyone thinks. Indeed, any specific H could be non-deterministic.

> Right, and the answer that H produces doesn't match the answer required
> by the problem statement, so is wrong.
If you know what answer is required by the problem-statement why are you even asking H?

You already know the answer - just produce it.

> Because the answer from a Halt Decider IS either correct or incorrect
> since it IS a pure "Binary" decision, that always has a answer.
This is incoherent. The Halt Decider returns whatever it returns.

Given program A - it returns True (halts)
Given program B - it returns False (it doesn't halt).

HOW do you know that "A halts" is a correct statement?
HOW do you know that "B doesn't halt" is a correct statement?

If you are disputing the results of H then not only are you implying that you also have a halt-decider; but you are implying that your halt-decider is disagrees with H and THEREFORE H is incorrect.

On Friday, 2 December 2022 at 14:28:01 UTC+2, richar...@gmail.com wrote:
> The problem is we are in a domain that is fully defined on this point,
> and the possible answer of H have strictly defined meanings.
If that were true then your formal system is necessarily complete.

> Olcott seem to think that this specific H can sometimes give one answer
> and sometimes another.
It's not a matter of what anyone thinks. Indeed, any specific H could be non-deterministic.

> Right, and the answer that H produces doesn't match the answer required
> by the problem statement, so is wrong.
If you know what answer is required by the problem-statement why are you even asking H?

You already know the answer - just produce it.

> Because the answer from a Halt Decider IS either correct or incorrect
> since it IS a pure "Binary" decision, that always has a answer.
This is incoherent. The Halt Decider returns whatever it returns.

Given program A - it returns True (halts)
Given program B - it returns False (it doesn't halt).

HOW do you know that "A halts" is a correct statement?
HOW do you know that "B doesn't halt" is a correct statement?

If you are disputing the results of H then not only are you implying that you also have a halt-decider; but you are implying that your halt-decider is disagrees with H and THEREFORE H is incorrect.

On 12/2/22 7:40 AM, Todor Genov wrote:
> On Friday, 2 December 2022 at 14:28:01 UTC+2, richar...@gmail.com wrote:
>> The problem is we are in a domain that is fully defined on this point,
>> and the possible answer of H have strictly defined meanings.
> If that were true then your formal system is necessarily complete.
>

No, completenes is about the PROVABILITY of statement. A statement can
be known to have a correct answer, but we can not actually know that answer.

>> Olcott seem to think that this specific H can sometimes give one answer
>> and sometimes another.
> It's not a matter of what anyone thinks. Indeed, any specific H could be non-deterministic.

Not an be a Turing Machine Equivalent.

>
>> Right, and the answer that H produces doesn't match the answer required
>> by the problem statement, so is wrong.
> If you know what answer is required by the problem-statement why are you even asking H?

So, you don't understand that problem either.

>
> You already know the answer - just produce it.

The problem is H needs to produce it, but can't

>
>> Because the answer from a Halt Decider IS either correct or incorrect
>> since it IS a pure "Binary" decision, that always has a answer.
> This is incoherent. The Halt Decider returns whatever it returns.
>
> Given program A - it returns True (halts)
> Given program B - it returns False (it doesn't halt).
>
> HOW do you know that "A halts" is a correct statement?
> HOW do you know that "B doesn't halt" is a correct statement?

A program that halts, can always be proven to halt by just running it
till it reaches that final step.

For programs that don't halt, we can often actually PROVE that they
don't, but not for all cases. That is actually one way to show the
Halting Problem.

Note, it is possible for us to not know if the answer from H is correct
or incorrect.

If H answers Halting, and it is correct, we can prove it correct by just
running the input program.

If H answers Halting, and that is incorrect, we MIGHT be able to prove
it wrong, if this is a case that we can prove to be non-halting.

If H answers Non-Halting, and that is incorrect, we can prove it wrong
by running the input and seeing it halt (as we do in the case in question).

If H answers Non-Halting, and that is correct, we MIGHT be able to prove
it right, or we might not.

This shows the difference between PROVING something is correct or
incorrect or it actually being correct or incorrect.

A binary, but non-computable, answer WILL be either correct or
incorrect, but we might not know which it is in a given case.

>
> If you are disputing the results of H then not only are you implying that you also have a halt-decider; but you are implying that your halt-decider is disagrees with H and THEREFORE H is incorrect.
>
>

No, we can show that THIS program WILL halt if H returns non-halting, so
we can prove that this H gave the wrong answer.

For the original proof, we can also prove that the H^ program WILL be
non-halting if the H is shown to return Halting for H applied to H^ H^,
in part because the final state of H^ is exactly the code step for the
final state of H that says Halting.

The only way we can't show the halting behavior of this H^ is it we
don't know if H gives an answer, but to be a Halt Decider it MUST give
an answer, so we can actually PROVE that IF it gives an answer, it is
wrong, and if it doesn't give an answer, then it is also wrong by
definition.

Halting is a property which obeys the law of the excluded middle, so we
have shown that H must be wrong.

To disprove a machine from being a Halt Decider, since that requires
being able to answer correctly about EVERY input, we only need to show
it wrong about one. There may be many other answers we can't determine
if it is right or wrong, but if we can show it wrong about one, it is wrong.

The H^ template has the special property that we can show that H WILL be
wrong (either by giving the wrong answer or by not answering) for any
possible decider H we build it on, because it uses a copy of that
decider to ask it the same question. This lets us prove that ALL
machines that might claim to be halt deciders have to be wrong about a
specific program built from them.

On 12/2/22 7:48 AM, Skep Dick wrote:
> On Friday, 2 December 2022 at 14:28:01 UTC+2, richar...@gmail.com wrote:
>> The problem is we are in a domain that is fully defined on this point,
>> and the possible answer of H have strictly defined meanings.
> If that were true then your formal system is necessarily complete.
>
>> Olcott seem to think that this specific H can sometimes give one answer
>> and sometimes another.
> It's not a matter of what anyone thinks. Indeed, any specific H could be non-deterministic.
>
>> Right, and the answer that H produces doesn't match the answer required
>> by the problem statement, so is wrong.
> If you know what answer is required by the problem-statement why are you even asking H?
>
> You already know the answer - just produce it.
>
>> Because the answer from a Halt Decider IS either correct or incorrect
>> since it IS a pure "Binary" decision, that always has a answer.
> This is incoherent. The Halt Decider returns whatever it returns.
>
> Given program A - it returns True (halts)
> Given program B - it returns False (it doesn't halt).
>
> HOW do you know that "A halts" is a correct statement?
> HOW do you know that "B doesn't halt" is a correct statement?
>
> If you are disputing the results of H then not only are you implying that you also have a halt-decider; but you are implying that your halt-decider is disagrees with H and THEREFORE H is incorrect.

So, did you just break your "Secret Identity"?

On Friday, 2 December 2022 at 15:01:55 UTC+2, richar...@gmail.com wrote:
> No, completenes is about the PROVABILITY of statement.
>A statement can be known to have a correct answer, but we can not actually know that answer.
It's the exact same thing.

If you can't prove whether a **particular** answer is "correct" then your system is incomplete with respect to "correctness"!

What the hell does it mean for the statement "2+2" to have a correct answer if you can't actually determine whether 4 is a "correct" answer?

> >> Olcott seem to think that this specific H can sometimes give one answer
> >> and sometimes another.
> > It's not a matter of what anyone thinks. Indeed, any specific H could be non-deterministic.
> Not an be a Turing Machine Equivalent.
Nonsense. Deterministic and non-deterministic Turing Machines are sub-types of Turing Machines.

> So, you don't understand that problem either.
There's nothing to understand. You ask a question (2+2) - some function produces an answer (4).

The answer "4" is either correct or incorrect. Which one is it?

> > You already know the answer - just produce it.
> The problem is H needs to produce it, but can't
That's a lie. H produces an answer.

The answer H produces is either correct or incorrect. Which one is it?

> A program that halts, can always be proven to halt by just running it
> till it reaches that final step.
This is incoherent. a Proof IS a program. A proof either halts; or it doesn't.

> For programs that don't halt, we can often actually PROVE that they
> don't, but not for all cases. That is actually one way to show the
> Halting Problem.
Incoherent nonsense. How do you prove that a program halts when a proof is a program?

How do you prove that a proof halts?

> Note, it is possible for us to not know if the answer from H is correct
> or incorrect.
How do you know? Surely you must have some method in mind by which you can prove that an answer is "correct" or "incorrect"?

Provide it please.

> If H answers Halting, and it is correct, we can prove it correct by just
> running the input program.
Huh?!? How? Any running program could halt. Eventually.

If P hasn't yet halted but could in future WHEN do you assert that H was "incorrect" ?

> If H answers Halting, and that is incorrect, we MIGHT be able to prove
> it wrong, if this is a case that we can prove to be non-halting.
Huh?!? How? Proofs are programs.

What sort of program are you going to write which proves that another program halts?

> If H answers Non-Halting, and that is incorrect, we can prove it wrong
> by running the input and seeing it halt (as we do in the case in question).
But you would be doing EXACTLY what H did!?!?

It ran/simulated the program! How is your runner/simulator better than H's runner/simulator?

> If H answers Non-Halting, and that is correct, we MIGHT be able to prove
> it right, or we might not.
Huh?!? How?!? Proofs are programs.

What sort of program (other than H) would you produce to prove that another program doesn't halt?

> This shows the difference between PROVING something is correct or
> incorrect or it actually being correct or incorrect.
No, this shows sophistry. Proofs are programs.

If program A proves that program B is correct, you still have no proof that program A is correct about program B being correct.

> A binary, but non-computable, answer WILL be either correct or
> incorrect, but we might not know which it is in a given case.
You are equivocating "knowing".

How would you know whether an answer is "correct" in the cases where you can know?

> No, we can show that THIS program WILL halt....
How? Surely you have to run/simulate THIS program.

When you run/simulate THIS program - you are doing EXACTLY the same thing as the simulating halt-decider.

> we can prove that this H gave the wrong answer.
Oh, you can prove it. Can you? Proofs are programs.

Since you are volunteering a proof - please provide a program/proof which correctly determines that H is incorrect.

> For the original proof
In what programming language are you going to present this "proof"?

>we can also prove that the H^ program WILL be non-halting if the H is shown to return Halting for H applied to H^ H^
In what programming language are you going to present this "proof"?
>so we can actually PROVE that IF it gives an answer
In what programming language can we PROVE this?

> Halting is a property which obeys the law of the excluded middle, so we
> have shown that H must be wrong.
This is immaterial. Since both "halting" and "wrongness" are both non-trivial semantic properties subject to Rice's theorem.

> To disprove a machine from being a Halt Decider, since that requires
In what programming language are you going to disprove this?

> This lets us prove that ALL machines that might claim to be halt deciders have to be wrong about a specific program built from them.
What programming language lets you prove that?

Surely you are aware that you are guilty of equivocation? SURELY? Unless, of course you are not a logician.

Because you keep equivocating the term "proof", "to prove" and "program".
Proofs are not LIKE programs. Proofs are not related to programs but different.
Proofs ARE programs. They are two different words for exactly the same objects.

https://en.wikipedia.org/wiki/Curry%E2%80%93Howard_correspondence

On 12/2/2022 7:49 AM, Skep Dick wrote:
> On Friday, 2 December 2022 at 15:01:55 UTC+2, richar...@gmail.com wrote:
>> No, completenes is about the PROVABILITY of statement.
>> A statement can be known to have a correct answer, but we can not actually know that answer.
> It's the exact same thing.
>
> If you can't prove whether a **particular** answer is "correct" then your system is incomplete with respect to "correctness"!
>
> What the hell does it mean for the statement "2+2" to have a correct answer if you can't actually determine whether 4 is a "correct" answer?
>
>>>> Olcott seem to think that this specific H can sometimes give one answer
>>>> and sometimes another.
>>> It's not a matter of what anyone thinks. Indeed, any specific H could be non-deterministic.
>> Not an be a Turing Machine Equivalent.
> Nonsense. Deterministic and non-deterministic Turing Machines are sub-types of Turing Machines.
>
>> So, you don't understand that problem either.
> There's nothing to understand. You ask a question (2+2) - some function produces an answer (4).
>
> The answer "4" is either correct or incorrect. Which one is it?
>
>>> You already know the answer - just produce it.
>> The problem is H needs to produce it, but can't
> That's a lie. H produces an answer.
>
> The answer H produces is either correct or incorrect. Which one is it?

https://liarparadox.org/2022_11_14.zip

The H(D,D) of the above fully operational software system
correctly determines that its input specifies a non-halting
sequence of configurations according to this criteria:

If simulating halt decider H correctly simulates its
input D until H correctly determines that its simulated
D would never stop running unless aborted then H can
abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.

*Correct simulation of D by H* is defined as a line-by-line
mapping from the x86 source code of D to each line of the
execution trace of D.

Only a diverge of this mapping shows that the simulation is
incorrect, it is otherwise correct even if incomplete.

_D()
[000019b3] 55 push ebp
[000019b4] 8bec mov ebp,esp
[000019b6] 51 push ecx
[000019b7] 8b4508 mov eax,[ebp+08]
[000019ba] 50 push eax
[000019bb] 8b4d08 mov ecx,[ebp+08]
[000019be] 51 push ecx
[000019bf] e8bff9ffff call 00001383
[000019c4] 83c408 add esp,+08
[000019c7] 8945fc mov [ebp-04],eax
[000019ca] 837dfc00 cmp dword [ebp-04],+00
[000019ce] 7402 jz 000019d2
[000019d0] ebfe jmp 000019d0
[000019d2] 8be5 mov esp,ebp
[000019d4] 5d pop ebp
[000019d5] c3 ret
Size in bytes:(0035) [000019d5]

_main()
[000019e3] 55 push ebp
[000019e4] 8bec mov ebp,esp
[000019e6] 68b3190000 push 000019b3 // push D
[000019eb] 68b3190000 push 000019b3 // push D
[000019f0] e88ef9ffff call 00001383 // call H
[000019f5] 83c408 add esp,+08
[000019f8] 33c0 xor eax,eax
[000019fa] 5d pop ebp
[000019fb] c3 ret
Size in bytes:(0025) [000019fb]

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[000019e3][00102a39][00000000] 55 push ebp // begin main
[000019e4][00102a39][00000000] 8bec mov ebp,esp
[000019e6][00102a35][000019b3] 68b3190000 push 000019b3 // push D
[000019eb][00102a31][000019b3] 68b3190000 push 000019b3 // push D
[000019f0][00102a2d][000019f5] e88ef9ffff call 00001383 // call H

When H correctly simulates D it finds that D remains stuck in recursive
simulation

H: Begin Simulation Execution Trace Stored at:112ae5
Address_of_H:1383
[000019b3][00112ad1][00112ad5] 55 push ebp // begin D
[000019b4][00112ad1][00112ad5] 8bec mov ebp,esp
[000019b6][00112acd][00102aa1] 51 push ecx
[000019b7][00112acd][00102aa1] 8b4508 mov eax,[ebp+08]
[000019ba][00112ac9][000019b3] 50 push eax // call D
[000019bb][00112ac9][000019b3] 8b4d08 mov ecx,[ebp+08]
[000019be][00112ac5][000019b3] 51 push ecx // push D
[000019bf][00112ac1][000019c4] e8bff9ffff call 00001383 // call H
H: Infinitely Recursive Simulation Detected Simulation Stopped

We can see that the first seven instructions of D simulated by H
precisely match the first seven instructions of the x86 source-code of
D. This conclusively proves that these instructions were simulated
correctly.

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

On Friday, 2 December 2022 at 17:54:32 UTC+2, olcott wrote:
> On 12/2/2022 7:49 AM, Skep Dick wrote:
> > On Friday, 2 December 2022 at 15:01:55 UTC+2, richar...@gmail.com wrote:
> >> No, completenes is about the PROVABILITY of statement.
> >> A statement can be known to have a correct answer, but we can not actually know that answer.
> > It's the exact same thing.
> >
> > If you can't prove whether a **particular** answer is "correct" then your system is incomplete with respect to "correctness"!
> >
> > What the hell does it mean for the statement "2+2" to have a correct answer if you can't actually determine whether 4 is a "correct" answer?
> >
> >>>> Olcott seem to think that this specific H can sometimes give one answer
> >>>> and sometimes another.
> >>> It's not a matter of what anyone thinks. Indeed, any specific H could be non-deterministic.
> >> Not an be a Turing Machine Equivalent.
> > Nonsense. Deterministic and non-deterministic Turing Machines are sub-types of Turing Machines.
> >
> >> So, you don't understand that problem either.
> > There's nothing to understand. You ask a question (2+2) - some function produces an answer (4).
> >
> > The answer "4" is either correct or incorrect. Which one is it?
> >
> >>> You already know the answer - just produce it.
> >> The problem is H needs to produce it, but can't
> > That's a lie. H produces an answer.
> >
> > The answer H produces is either correct or incorrect. Which one is it?
> https://liarparadox.org/2022_11_14.zip
>
> The H(D,D) of the above fully operational software system
> correctly determines that its input specifies a non-halting
> sequence of configurations according to this criteria:
>
> If simulating halt decider H correctly simulates its
> input D until H correctly determines that its simulated
> D would never stop running unless aborted then H can
> abort its simulation of D and correctly report that D
> specifies a non-halting sequence of configurations.
> *Correct simulation of D by H* is defined as a line-by-line
> mapping from the x86 source code of D to each line of the
> execution trace of D.
>
> Only a diverge of this mapping shows that the simulation is
> incorrect, it is otherwise correct even if incomplete.
>
> _D()
> [000019b3] 55 push ebp
> [000019b4] 8bec mov ebp,esp
> [000019b6] 51 push ecx
> [000019b7] 8b4508 mov eax,[ebp+08]
> [000019ba] 50 push eax
> [000019bb] 8b4d08 mov ecx,[ebp+08]
> [000019be] 51 push ecx
> [000019bf] e8bff9ffff call 00001383
> [000019c4] 83c408 add esp,+08
> [000019c7] 8945fc mov [ebp-04],eax
> [000019ca] 837dfc00 cmp dword [ebp-04],+00
> [000019ce] 7402 jz 000019d2
> [000019d0] ebfe jmp 000019d0
> [000019d2] 8be5 mov esp,ebp
> [000019d4] 5d pop ebp
> [000019d5] c3 ret
> Size in bytes:(0035) [000019d5]
>
> _main()
> [000019e3] 55 push ebp
> [000019e4] 8bec mov ebp,esp
> [000019e6] 68b3190000 push 000019b3 // push D
> [000019eb] 68b3190000 push 000019b3 // push D
> [000019f0] e88ef9ffff call 00001383 // call H
> [000019f5] 83c408 add esp,+08
> [000019f8] 33c0 xor eax,eax
> [000019fa] 5d pop ebp
> [000019fb] c3 ret
> Size in bytes:(0025) [000019fb]
>
> machine stack stack machine assembly
> address address data code language
> ======== ======== ======== ========= =============
> [000019e3][00102a39][00000000] 55 push ebp // begin main
> [000019e4][00102a39][00000000] 8bec mov ebp,esp
> [000019e6][00102a35][000019b3] 68b3190000 push 000019b3 // push D
> [000019eb][00102a31][000019b3] 68b3190000 push 000019b3 // push D
> [000019f0][00102a2d][000019f5] e88ef9ffff call 00001383 // call H
>
> When H correctly simulates D it finds that D remains stuck in recursive
> simulation
>
> H: Begin Simulation Execution Trace Stored at:112ae5
> Address_of_H:1383
> [000019b3][00112ad1][00112ad5] 55 push ebp // begin D
> [000019b4][00112ad1][00112ad5] 8bec mov ebp,esp
> [000019b6][00112acd][00102aa1] 51 push ecx
> [000019b7][00112acd][00102aa1] 8b4508 mov eax,[ebp+08]
> [000019ba][00112ac9][000019b3] 50 push eax // call D
> [000019bb][00112ac9][000019b3] 8b4d08 mov ecx,[ebp+08]
> [000019be][00112ac5][000019b3] 51 push ecx // push D
> [000019bf][00112ac1][000019c4] e8bff9ffff call 00001383 // call H
> H: Infinitely Recursive Simulation Detected Simulation Stopped
>
> We can see that the first seven instructions of D simulated by H
> precisely match the first seven instructions of the x86 source-code of
> D. This conclusively proves that these instructions were simulated
> correctly.
> --
> Copyright 2022 Olcott "Talent hits a target no one else can hit; Genius
> hits a target no one else can see." Arthur Schopenhauer

Shut up, Olcott.

Everything you've done so far is one giant, pointless tautology.

It's an argument from authority. Your H(D,D) function is the authority you've appointed to decide the "correctness" property.

On Friday, 2 December 2022 at 17:54:32 UTC+2, olcott wrote:
> This conclusively proves that these instructions were simulated
> correctly.
You are doing the exact same thing as the other moron. Asserting "correctness" instead of proving it.

What makes the simulation "correct"? Show me the source code for the "correctness" decider.

On 12/2/2022 10:03 AM, Skep Dick wrote:
> On Friday, 2 December 2022 at 17:54:32 UTC+2, olcott wrote:
>> On 12/2/2022 7:49 AM, Skep Dick wrote:
>>> On Friday, 2 December 2022 at 15:01:55 UTC+2, richar...@gmail.com wrote:
>>>> No, completenes is about the PROVABILITY of statement.
>>>> A statement can be known to have a correct answer, but we can not actually know that answer.
>>> It's the exact same thing.
>>>
>>> If you can't prove whether a **particular** answer is "correct" then your system is incomplete with respect to "correctness"!
>>>
>>> What the hell does it mean for the statement "2+2" to have a correct answer if you can't actually determine whether 4 is a "correct" answer?
>>>
>>>>>> Olcott seem to think that this specific H can sometimes give one answer
>>>>>> and sometimes another.
>>>>> It's not a matter of what anyone thinks. Indeed, any specific H could be non-deterministic.
>>>> Not an be a Turing Machine Equivalent.
>>> Nonsense. Deterministic and non-deterministic Turing Machines are sub-types of Turing Machines.
>>>
>>>> So, you don't understand that problem either.
>>> There's nothing to understand. You ask a question (2+2) - some function produces an answer (4).
>>>
>>> The answer "4" is either correct or incorrect. Which one is it?
>>>
>>>>> You already know the answer - just produce it.
>>>> The problem is H needs to produce it, but can't
>>> That's a lie. H produces an answer.
>>>
>>> The answer H produces is either correct or incorrect. Which one is it?
>> https://liarparadox.org/2022_11_14.zip
>>
>> The H(D,D) of the above fully operational software system
>> correctly determines that its input specifies a non-halting
>> sequence of configurations according to this criteria:
>>
>> If simulating halt decider H correctly simulates its
>> input D until H correctly determines that its simulated
>> D would never stop running unless aborted then H can
>> abort its simulation of D and correctly report that D
>> specifies a non-halting sequence of configurations.
>> *Correct simulation of D by H* is defined as a line-by-line
>> mapping from the x86 source code of D to each line of the
>> execution trace of D.
>>
>> Only a diverge of this mapping shows that the simulation is
>> incorrect, it is otherwise correct even if incomplete.
>>
>> _D()
>> [000019b3] 55 push ebp
>> [000019b4] 8bec mov ebp,esp
>> [000019b6] 51 push ecx
>> [000019b7] 8b4508 mov eax,[ebp+08]
>> [000019ba] 50 push eax
>> [000019bb] 8b4d08 mov ecx,[ebp+08]
>> [000019be] 51 push ecx
>> [000019bf] e8bff9ffff call 00001383
>> [000019c4] 83c408 add esp,+08
>> [000019c7] 8945fc mov [ebp-04],eax
>> [000019ca] 837dfc00 cmp dword [ebp-04],+00
>> [000019ce] 7402 jz 000019d2
>> [000019d0] ebfe jmp 000019d0
>> [000019d2] 8be5 mov esp,ebp
>> [000019d4] 5d pop ebp
>> [000019d5] c3 ret
>> Size in bytes:(0035) [000019d5]
>>
>> _main()
>> [000019e3] 55 push ebp
>> [000019e4] 8bec mov ebp,esp
>> [000019e6] 68b3190000 push 000019b3 // push D
>> [000019eb] 68b3190000 push 000019b3 // push D
>> [000019f0] e88ef9ffff call 00001383 // call H
>> [000019f5] 83c408 add esp,+08
>> [000019f8] 33c0 xor eax,eax
>> [000019fa] 5d pop ebp
>> [000019fb] c3 ret
>> Size in bytes:(0025) [000019fb]
>>
>> machine stack stack machine assembly
>> address address data code language
>> ======== ======== ======== ========= =============
>> [000019e3][00102a39][00000000] 55 push ebp // begin main
>> [000019e4][00102a39][00000000] 8bec mov ebp,esp
>> [000019e6][00102a35][000019b3] 68b3190000 push 000019b3 // push D
>> [000019eb][00102a31][000019b3] 68b3190000 push 000019b3 // push D
>> [000019f0][00102a2d][000019f5] e88ef9ffff call 00001383 // call H
>>
>> When H correctly simulates D it finds that D remains stuck in recursive
>> simulation
>>
>> H: Begin Simulation Execution Trace Stored at:112ae5
>> Address_of_H:1383
>> [000019b3][00112ad1][00112ad5] 55 push ebp // begin D
>> [000019b4][00112ad1][00112ad5] 8bec mov ebp,esp
>> [000019b6][00112acd][00102aa1] 51 push ecx
>> [000019b7][00112acd][00102aa1] 8b4508 mov eax,[ebp+08]
>> [000019ba][00112ac9][000019b3] 50 push eax // call D
>> [000019bb][00112ac9][000019b3] 8b4d08 mov ecx,[ebp+08]
>> [000019be][00112ac5][000019b3] 51 push ecx // push D
>> [000019bf][00112ac1][000019c4] e8bff9ffff call 00001383 // call H
>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>
>> We can see that the first seven instructions of D simulated by H
>> precisely match the first seven instructions of the x86 source-code of
>> D. This conclusively proves that these instructions were simulated
>> correctly.
>> --
>> Copyright 2022 Olcott "Talent hits a target no one else can hit; Genius
>> hits a target no one else can see." Arthur Schopenhauer
>
> Shut up, Olcott.
>
> Everything you've done so far is one giant, pointless tautology.
>
> It's an argument from authority. Your H(D,D) function is the authority you've appointed to decide the "correctness" property.

The entire body of analytic knowledge of the analytic/synthetic
distinction is a subset of the body of analytic truth. Every element of
the body of analytic truth is only true because of mutual semantic
tautologies with other elements in this body.

“Analytic” sentences, such as “Pediatricians are doctors,” have
historically been characterized as ones that are true by virtue of the
meanings of their words alone and/or can be known to be so solely by
knowing those meanings.
https://plato.stanford.edu/entries/analytic-synthetic/ *AKA mutual
semantic tautologies*

A philosopher of logic examines the foundations of logic (thinking
outside the box) whereas logicians merely take these foundations for
granted and force all of their thinking inside the box of these given
foundations. This makes all logicians utterly blind to foundational
errors.

This conventional definition of Incomplete(T)
Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ))
is proven to be incorrect on the basis that every self-contradictory
expression of language φ "proves" that T is "Incomplete".

Here is the correct assessment:
Not_a_Truth_Bearer_in_T(φ) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ))

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

On 12/2/2022 10:21 AM, Skep Dick wrote:
> On Friday, 2 December 2022 at 17:54:32 UTC+2, olcott wrote:
>> This conclusively proves that these instructions were simulated
>> correctly.
> You are doing the exact same thing as the other moron. Asserting "correctness" instead of proving it.
>
> What makes the simulation "correct"? Show me the source code for the "correctness" decider.
>

How do you prove that a "pile of bricks" is not a type of {baby kitten}?

Stipulated relations between concepts forming mutually self-defining
semantic tautologies encoded as finite strings.

AKA the body of analytic truth of the analytic/synthetic distinction.
https://plato.stanford.edu/entries/analytic-synthetic/

“Analytic” sentences ... are true by virtue of the meanings
of their words alone and/or can be known to be so solely by
knowing those meanings.

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

On Friday, 2 December 2022 at 18:26:33 UTC+2, olcott wrote:
> The entire body of analytic knowledge of the analytic/synthetic
> distinction is a subset of the body of analytic truth. Every element of
> the body of analytic truth is only true because of mutual semantic
> tautologies with other elements in this body.
>
> “Analytic” sentences, such as “Pediatricians are doctors,” have
> historically been characterized as ones that are true by virtue of the
> meanings of their words alone and/or can be known to be so solely by
> knowing those meanings.
> https://plato.stanford.edu/entries/analytic-synthetic/ *AKA mutual
> semantic tautologies*
Not going through this nonsense with you again.

Everything in computation is strictly structuralism - it's about the elements and structure of sets/spaces/types (however you conceptualise them) and relations between those spaces.
Your philosophical grounding is wonky.

> A philosopher of logic examines the foundations of logic (thinking
> outside the box) whereas logicians merely take these foundations for
> granted and force all of their thinking inside the box of these given
> foundations. This makes all logicians utterly blind to foundational
> errors.
Yes. It's called metalogic. You have no idea what an "error" is in logical terms.
And you haven't defined it in metalogical terms.

> This conventional definition of Incomplete(T)
> Incomplete(T) ↔ ∃φ ((T ⊬ φ) ∧ (T ⊬ ¬φ))
> is proven to be incorrect on the basis that every self-contradictory
> expression of language φ "proves" that T is "Incomplete".
Your head is so far up your ass you don't even know that ∃φ ∨ ¬∃φ is a computational statement. A decision procedure.
It's a statement that Either ∃φ is true; or ¬∃φ is true. You've heard of the Either monad, right?

On Friday, 2 December 2022 at 18:35:57 UTC+2, olcott wrote:
> How do you prove that a "pile of bricks" is not a type of {baby kitten}?
You don't.

Proof theory is about formal systems. It has nothing to do with the real world.

On 12/2/2022 10:45 AM, Skep Dick wrote:
> On Friday, 2 December 2022 at 18:35:57 UTC+2, olcott wrote:
>> How do you prove that a "pile of bricks" is not a type of {baby kitten}?
> You don't.
>
> Proof theory is about formal systems. It has nothing to do with the real world.

Proof theory is not theory end all be all of every sort of proof.

The way that you prove that a "pile of bricks" is not a type of
{baby kitten} is within the knowledge ontology defining the
semantic meaning of natural language words.

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

On Friday, 2 December 2022 at 18:55:13 UTC+2, olcott wrote:
> Proof theory is not theory end all be all of every sort of proof.
It is. That's why it's called "proof theory" because it's about proofs being actual Mathematical objects.

If you have some other theory about what it means "to prove" something - share it with us.
> The way that you prove that a "pile of bricks" is not a type of
> {baby kitten} is within the knowledge ontology defining the
> semantic meaning of natural language words.
You are incredibly confused. "Knowledge ontology" is an oxymoron.

You have confused epistemology and ontology.

On Friday, 2 December 2022 at 18:55:13 UTC+2, olcott wrote:
> The way that you prove that a "pile of bricks" is not a type of
> {baby kitten} is within the knowledge ontology defining the
> semantic meaning of natural language words.
Your stupidity stems from confusing syntax and semantics.

The syntax says "This text is black". Define the semantics of "black" and prove that the sentence is true.

On Fri, 02 Dec 2022 09:24:27 -0800, Skep Dick wrote:

> On Friday, 2 December 2022 at 18:55:13 UTC+2, olcott wrote:
>> The way that you prove that a "pile of bricks" is not a type of {baby
>> kitten} is within the knowledge ontology defining the semantic meaning
>> of natural language words.
> Your stupidity stems from confusing syntax and semantics.
>
> The syntax says "This text is black". Define the semantics of "black"
> and prove that the sentence is true.

A semantic definition can be constrained by the abstraction layer to which
it is being applied.

/Flibble

On 12/2/2022 11:18 AM, Skep Dick wrote:
> On Friday, 2 December 2022 at 18:55:13 UTC+2, olcott wrote:
>> Proof theory is not theory end all be all of every sort of proof.
> It is. That's why it's called "proof theory" because it's about proofs being actual Mathematical objects.
>
> If you have some other theory about what it means "to prove" something - share it with us.

{Prove} always means applying truth preserving operations to expressions
of language deriving another expression of language typically called the
consequence/conclusion.

>
>> The way that you prove that a "pile of bricks" is not a type of
>> {baby kitten} is within the knowledge ontology defining the
>> semantic meaning of natural language words.
> You are incredibly confused. "Knowledge ontology" is an oxymoron.
>
> You have confused epistemology and ontology.

In computer science and information science, an ontology encompasses a
representation, formal naming, and definition of the categories,
properties, and relations between the concepts, data, and entities that
substantiate one, many, or all domains of discourse.
https://en.wikipedia.org/wiki/Ontology_(information_science)

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