On 6/30/2022 6:05 PM, Dennis Bush wrote:
> On Thursday, June 30, 2022 at 6:57:12 PM UTC-4, olcott wrote:
>> On 6/30/2022 5:26 PM, Dennis Bush wrote:
>>> On Thursday, June 30, 2022 at 6:23:56 PM UTC-4, olcott wrote:
>>>> On 6/30/2022 5:09 PM, Dennis Bush wrote:
>>>>> On Thursday, June 30, 2022 at 5:52:37 PM UTC-4, olcott wrote:
>>>>>> On 6/30/2022 3:50 PM, Dennis Bush wrote:
>>>>>>> On Thursday, June 30, 2022 at 4:22:57 PM UTC-4, olcott wrote:
>>>>>>>> On 6/30/2022 11:55 AM, Dennis Bush wrote:
>>>>>>>>> On Thursday, June 30, 2022 at 12:43:17 PM UTC-4, olcott wrote:
>>>>>>>>>> On 6/30/2022 11:34 AM, Dennis Bush wrote:
>>>>>>>>>>> On Thursday, June 30, 2022 at 12:15:58 PM UTC-4, olcott wrote:
>>>>>>>>>>>> On 6/30/2022 10:40 AM, Dennis Bush wrote:
>>>>>>>>>>>>> On Thursday, June 30, 2022 at 11:36:43 AM UTC-4, olcott wrote:
>>>>>>>>>>>>>> On 6/30/2022 7:12 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Thursday, June 30, 2022 at 12:59:38 AM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>> On 6/29/2022 11:51 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>> On Thursday, June 30, 2022 at 12:42:59 AM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>> On 6/29/2022 9:02 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>> On Wednesday, June 29, 2022 at 9:44:39 AM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 6/28/2022 8:44 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Every simulating halt decider correctly simulates its input until it
>>>>>>>>>>>>>>>>>>>> correctly determines that this simulated input would never reach its
>>>>>>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>>>>>>>> I don't know why you keep making the ridiculous assertion that a
>>>>>>>>>>>>>>>>>>>> simulating halt decider cannot possibly predict/determine that its
>>>>>>>>>>>>>>>>>>>> complete and correct x86 emulation of its input would never reach the
>>>>>>>>>>>>>>>>>>>> "ret" instruction of this input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> But Ha doesn't *do* a complete and correct emulation of its input as per its fixed algorithm, so to say what the complete and correct emulation of the input to Ha(Pa,Pa) by Ha is, is simply nonsense.
>>>>>>>>>>>>>>>>>> To continue to insist that a simulating halt decider cannot correctly
>>>>>>>>>>>>>>>>>> predict (in a finite number of steps) that its complete and correct x86
>>>>>>>>>>>>>>>>>> emulation of its input
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Which does not exist because Ha aborts and therefore does not do a complete and correct x86 emulation.
>>>>>>>>>>>>>>>> We are taking that what you are saying means that you believe it is
>>>>>>>>>>>>>>>> impossible for H to correctly determine that Infinite_Loop() never halts.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, you're saying that the correctness criteria for Ha(Pa,Pa) is a complete and correct emulation of the input *by Ha*. And because Ha has a fixed algorithm that aborts, Ha does not do a complete and correct emulation of the input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> And because Ha does not do a complete and correct emulation of the input, what I'm saying is that your correctness criteria simply doesn't exist.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That is a Jackass (deceptive head games) thing to say when you already
>>>>>>>>>>>>>> know that H merely needs to correctly predict what the complete and
>>>>>>>>>>>>>> correct x86 emulation of its input would do and it need not actually to
>>>>>>>>>>>>>> a complete emulation to do this. EXAMPLE BELOW
>>>>>>>>>>>>>
>>>>>>>>>>>>> *The* complete and correct emulation of the input to Ha(Pa,Pa) is performed by UTM(Pa,Pa) which halts, proving that Ha(Pa,Pa)==0 is wrong.
>>>>>>>>>>>> The part that you keep erasing proves that you are a liar.
>>>>>>>>>>>> You keep erasing it because you know that it proves you are a liar.
>>>>>>>>>>>
>>>>>>>>>>> Infinite_Loop was previously shown to be irrelevant.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Changing the subject to a completely different computation UTM(Pa,Pa)
>>>>>>>>>>>> than the actual computation Ha(Pa,Pa) is the strawman deception.
>>>>>>>>>>>> straw man
>>>>>>>>>>>> An intentionally misrepresented proposition that is set up because it is
>>>>>>>>>>>> easier to defeat than an opponent's real argument.
>>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
>>>>>>>>>>>
>>>>>>>>>>> I'm not changing the subject. I'm just going by what you're saying.
>>>>>>>>>>>
>>>>>>>>>>>> THIS IS NECESSARILY TRUE THUS IMPOSSIBLY FALSE
>>>>>>>>>>>> Every simulating halt decider correctly simulates its input until it
>>>>>>>>>>>> correctly determines that this simulated input would never reach its
>>>>>>>>>>>> final state.
>>>>>>>>>>>
>>>>>>>>>>> You keep changing this part. Sometimes you say "the" simulated input, sometimes "its" simulated input, sometimes "this" simulated input.
>>>>>>>>>>>
>>>>>>>>>>> *The* complete and correct simulation of the input to Ha(Pa,Pa) is by definition performed by UTM(Pa,Pa).
>>>>>>>>>> That is a lie and you know it.
>>>>>>>>>>
>>>>>>>>>> The actual behavior of the actual input to H(P,P) is conclusively proven
>>>>>>>>>> to diverge from the actual behavior of the actual input to H1(P,P) on
>>>>>>>>>> the basis of the semantics of the x86 language.
>>>>>>>>>
>>>>>>>>> Then what is the first x86 instruction where the behavior of Ha(Pa,Pa) and UTM(Pa,Pa) differ?
>>>>>>>>>
>>>>>>>> [0000164a][00212749][0021274d] 83c408 add esp,+08
>>>>>>>
>>>>>>> FALSE
>>>>>>>
>>>>>>> The simulation performed by Ha is aborted before that instruction can be reached.
>>>>>> Aborted or not the above instruction is the first instruction that
>>>>>> differs.
>>>>>
>>>>> That instruction doesn't differ between the two simulations because Ha stopped before it got there.
>>>> Perhaps you are simply not bright enough to understand that aborted or
>>>> not the emulated input never reaches its "ret" instruction.
>>>
>>> Then you believe that Ha3(N,5)==0 is correct because the emulated input never reaches its "ret" instruction, correct?
>>>
>>> If not, then explain in detail why it is wrong. Failure to do so will be taken as you asserting that this is correct.
>> The problem is not that you are not bright enough the problem is that
>> you are a liar that continues to try and get away with the strawman
>> deception.
>
> You said "aborted or not the emulated input never reaches its "ret" instruction". There is no "not" since the fixed algorithm of Ha aborts, so you're saying that because Ha aborts that causes the "ret" instruction to not be reached which is your criteria for returning 0.

On Thursday, June 30, 2022 at 7:11:01 PM UTC-4, olcott wrote:
> On 6/30/2022 6:05 PM, Dennis Bush wrote:
> > On Thursday, June 30, 2022 at 6:57:12 PM UTC-4, olcott wrote:
> >> On 6/30/2022 5:26 PM, Dennis Bush wrote:
> >>> On Thursday, June 30, 2022 at 6:23:56 PM UTC-4, olcott wrote:
> >>>> On 6/30/2022 5:09 PM, Dennis Bush wrote:
> >>>>> On Thursday, June 30, 2022 at 5:52:37 PM UTC-4, olcott wrote:
> >>>>>> On 6/30/2022 3:50 PM, Dennis Bush wrote:
> >>>>>>> On Thursday, June 30, 2022 at 4:22:57 PM UTC-4, olcott wrote:
> >>>>>>>> On 6/30/2022 11:55 AM, Dennis Bush wrote:
> >>>>>>>>> On Thursday, June 30, 2022 at 12:43:17 PM UTC-4, olcott wrote:
> >>>>>>>>>> On 6/30/2022 11:34 AM, Dennis Bush wrote:
> >>>>>>>>>>> On Thursday, June 30, 2022 at 12:15:58 PM UTC-4, olcott wrote:
> >>>>>>>>>>>> On 6/30/2022 10:40 AM, Dennis Bush wrote:
> >>>>>>>>>>>>> On Thursday, June 30, 2022 at 11:36:43 AM UTC-4, olcott wrote:
> >>>>>>>>>>>>>> On 6/30/2022 7:12 AM, Dennis Bush wrote:
> >>>>>>>>>>>>>>> On Thursday, June 30, 2022 at 12:59:38 AM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>> On 6/29/2022 11:51 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>> On Thursday, June 30, 2022 at 12:42:59 AM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>> On 6/29/2022 9:02 AM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>> On Wednesday, June 29, 2022 at 9:44:39 AM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>> On 6/28/2022 8:44 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> Every simulating halt decider correctly simulates its input until it
> >>>>>>>>>>>>>>>>>>>> correctly determines that this simulated input would never reach its
> >>>>>>>>>>>>>>>>>>>> final state.
> >>>>>>>>>>>>>>>>>>>> I don't know why you keep making the ridiculous assertion that a
> >>>>>>>>>>>>>>>>>>>> simulating halt decider cannot possibly predict/determine that its
> >>>>>>>>>>>>>>>>>>>> complete and correct x86 emulation of its input would never reach the
> >>>>>>>>>>>>>>>>>>>> "ret" instruction of this input.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> But Ha doesn't *do* a complete and correct emulation of its input as per its fixed algorithm, so to say what the complete and correct emulation of the input to Ha(Pa,Pa) by Ha is, is simply nonsense.
> >>>>>>>>>>>>>>>>>> To continue to insist that a simulating halt decider cannot correctly
> >>>>>>>>>>>>>>>>>> predict (in a finite number of steps) that its complete and correct x86
> >>>>>>>>>>>>>>>>>> emulation of its input
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Which does not exist because Ha aborts and therefore does not do a complete and correct x86 emulation.
> >>>>>>>>>>>>>>>> We are taking that what you are saying means that you believe it is
> >>>>>>>>>>>>>>>> impossible for H to correctly determine that Infinite_Loop() never halts.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> No, you're saying that the correctness criteria for Ha(Pa,Pa) is a complete and correct emulation of the input *by Ha*. And because Ha has a fixed algorithm that aborts, Ha does not do a complete and correct emulation of the input.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> And because Ha does not do a complete and correct emulation of the input, what I'm saying is that your correctness criteria simply doesn't exist.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>> That is a Jackass (deceptive head games) thing to say when you already
> >>>>>>>>>>>>>> know that H merely needs to correctly predict what the complete and
> >>>>>>>>>>>>>> correct x86 emulation of its input would do and it need not actually to
> >>>>>>>>>>>>>> a complete emulation to do this. EXAMPLE BELOW
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> *The* complete and correct emulation of the input to Ha(Pa,Pa) is performed by UTM(Pa,Pa) which halts, proving that Ha(Pa,Pa)==0 is wrong.
> >>>>>>>>>>>> The part that you keep erasing proves that you are a liar.
> >>>>>>>>>>>> You keep erasing it because you know that it proves you are a liar.
> >>>>>>>>>>>
> >>>>>>>>>>> Infinite_Loop was previously shown to be irrelevant.
> >>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> Changing the subject to a completely different computation UTM(Pa,Pa)
> >>>>>>>>>>>> than the actual computation Ha(Pa,Pa) is the strawman deception.
> >>>>>>>>>>>> straw man
> >>>>>>>>>>>> An intentionally misrepresented proposition that is set up because it is
> >>>>>>>>>>>> easier to defeat than an opponent's real argument.
> >>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
> >>>>>>>>>>>
> >>>>>>>>>>> I'm not changing the subject. I'm just going by what you're saying.
> >>>>>>>>>>>
> >>>>>>>>>>>> THIS IS NECESSARILY TRUE THUS IMPOSSIBLY FALSE
> >>>>>>>>>>>> Every simulating halt decider correctly simulates its input until it
> >>>>>>>>>>>> correctly determines that this simulated input would never reach its
> >>>>>>>>>>>> final state.
> >>>>>>>>>>>
> >>>>>>>>>>> You keep changing this part. Sometimes you say "the" simulated input, sometimes "its" simulated input, sometimes "this" simulated input.
> >>>>>>>>>>>
> >>>>>>>>>>> *The* complete and correct simulation of the input to Ha(Pa,Pa) is by definition performed by UTM(Pa,Pa).
> >>>>>>>>>> That is a lie and you know it.
> >>>>>>>>>>
> >>>>>>>>>> The actual behavior of the actual input to H(P,P) is conclusively proven
> >>>>>>>>>> to diverge from the actual behavior of the actual input to H1(P,P) on
> >>>>>>>>>> the basis of the semantics of the x86 language.
> >>>>>>>>>
> >>>>>>>>> Then what is the first x86 instruction where the behavior of Ha(Pa,Pa) and UTM(Pa,Pa) differ?
> >>>>>>>>>
> >>>>>>>> [0000164a][00212749][0021274d] 83c408 add esp,+08
> >>>>>>>
> >>>>>>> FALSE
> >>>>>>>
> >>>>>>> The simulation performed by Ha is aborted before that instruction can be reached.
> >>>>>> Aborted or not the above instruction is the first instruction that
> >>>>>> differs.
> >>>>>
> >>>>> That instruction doesn't differ between the two simulations because Ha stopped before it got there.
> >>>> Perhaps you are simply not bright enough to understand that aborted or
> >>>> not the emulated input never reaches its "ret" instruction.
> >>>
> >>> Then you believe that Ha3(N,5)==0 is correct because the emulated input never reaches its "ret" instruction, correct?
> >>>
> >>> If not, then explain in detail why it is wrong. Failure to do so will be taken as you asserting that this is correct.
> >> The problem is not that you are not bright enough the problem is that
> >> you are a liar that continues to try and get away with the strawman
> >> deception.
> >
> > You said "aborted or not the emulated input never reaches its "ret" instruction". There is no "not" since the fixed algorithm of Ha aborts, so you're saying that because Ha aborts that causes the "ret" instruction to not be reached which is your criteria for returning 0.
> *This is necessarily true thus impossibly false*
> Every simulating halt decider that correctly simulates its input until
> it correctly determines that this simulated input would never reach its
> final state, correctly rejects this input as non-halting.

On 2022-06-30 18:30:10 +0000, olcott said:

> On 6/30/2022 1:22 PM, Mikko wrote:
>> On 2022-06-29 13:00:16 +0000, olcott said:
>>
>>> IT IS THIS SIMPLE PRINCIPLE THAT REFUTES THE HALTING PROBLEM PROOFS:
>>> Every simulating halt decider correctly simulates its input until it
>>> correctly determines that this simulated input would never reach its
>>> final state.
>>
>> That does not refute any halting problem proof. Instead, you should prove:
>> Some simulating halt decider correctly simulates its input until it
>> correctly determines that this simulated input would never reach its
>> final state.
>>
>> Mikko
>
> I do not see any material difference between the two.

For proofs the logical difference between "every" and "some" is more
important. In more formal logic ∀ and ∃ are used and they are very
different. A common vernacular term for ∀ is "every" or "for every"
but "all" or "for all" is also used and sometimes "each" or "for each".
For ∃ the vernacular term "some" is often used, or "there is" if one
wants to use a verb.

The reason there is a logical difference is that there is a material
difference. This is best illustrated by an example. One of the
examples of Aristotle was unicorn, so we can use that, too. So, is
the sentence "Every unicorn is green" true? Yes, because there is
no unicorn that is not green. Is the sentence "Some unicorn is green" true?
No, it is false, because no green unicorn exists. So the sentences are
materially different. That material difference is the material difference
between "every" and "some" (more formally, btween ∀ and ∃) as there is
no other difference between the sentences.

Mikko

On Friday, 1 July 2022 at 09:55:57 UTC+1, Mikko wrote:
> On 2022-06-30 18:30:10 +0000, olcott said:
>
> > On 6/30/2022 1:22 PM, Mikko wrote:
> >> On 2022-06-29 13:00:16 +0000, olcott said:
> >>
> >>> IT IS THIS SIMPLE PRINCIPLE THAT REFUTES THE HALTING PROBLEM PROOFS:
> >>> Every simulating halt decider correctly simulates its input until it
> >>> correctly determines that this simulated input would never reach its
> >>> final state.
> >>
> >> That does not refute any halting problem proof. Instead, you should prove:
> >> Some simulating halt decider correctly simulates its input until it
> >> correctly determines that this simulated input would never reach its
> >> final state.
> >>
> >> Mikko
> >
> > I do not see any material difference between the two.
> For proofs the logical difference between "every" and "some" is more
> important. In more formal logic ∀ and ∃ are used and they are very
> different. A common vernacular term for ∀ is "every" or "for every"
> but "all" or "for all" is also used and sometimes "each" or "for each".
> For ∃ the vernacular term "some" is often used, or "there is" if one
> wants to use a verb.
>
> The reason there is a logical difference is that there is a material
> difference. This is best illustrated by an example. One of the
> examples of Aristotle was unicorn, so we can use that, too. So, is
> the sentence "Every unicorn is green" true? Yes, because there is
> no unicorn that is not green. Is the sentence "Some unicorn is green" true?
> No, it is false, because no green unicorn exists. So the sentences are
> materially different. That material difference is the material difference
> between "every" and "some" (more formally, btween ∀ and ∃) as there is
> no other difference between the sentences.
>
I don't know about formal logic, but this doesn't make sense for natural
language. Every unicorn has one horn, because a unicorn is a horse
with one horn. But "every unicorn has two horns" is false, even though
there are no unicorns.

On 7/1/2022 3:55 AM, Mikko wrote:
> On 2022-06-30 18:30:10 +0000, olcott said:
>
>> On 6/30/2022 1:22 PM, Mikko wrote:
>>> On 2022-06-29 13:00:16 +0000, olcott said:
>>>
>>>> IT IS THIS SIMPLE PRINCIPLE THAT REFUTES THE HALTING PROBLEM PROOFS:
>>>> Every simulating halt decider correctly simulates its input until it
>>>> correctly determines that this simulated input would never reach its
>>>> final state.
>>>
>>> That does not refute any halting problem proof. Instead, you should
>>> prove:
>>> Some simulating halt decider correctly simulates its input until it
>>> correctly determines that this simulated input would never reach its
>>> final state.
>>>
>>> Mikko
>>
>> I do not see any material difference between the two.
>
> For proofs the logical difference between "every" and "some" is more
> important. In more formal logic ∀ and ∃ are used and they are very
> different. A common vernacular term for ∀ is "every" or "for every"
> but "all" or "for all" is also used and sometimes "each" or "for each".
> For ∃ the vernacular term "some" is often used, or "there is" if one
> wants to use a verb.
>

I mean every:

*This is necessarily true thus impossibly false*
Every simulating halt decider that correctly simulates its input until
it correctly determines that this simulated input would never reach its
final state, correctly rejects this input as non-halting.

> The reason there is a logical difference is that there is a material
> difference. This is best illustrated by an example. One of the
> examples of Aristotle was unicorn, so we can use that, too. So, is
> the sentence "Every unicorn is green" true? Yes, because there is
> no unicorn that is not green. Is the sentence "Some unicorn is green" true?
> No, it is false, because no green unicorn exists. So the sentences are
> materially different. That material difference is the material difference
> between "every" and "some" (more formally, btween ∀ and ∃) as there is
> no other difference between the sentences.
>
> Mikko
>
>
>

--
Copyright 2022 Pete Olcott

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

On 7/1/2022 7:37 AM, Malcolm McLean wrote:
> On Friday, 1 July 2022 at 09:55:57 UTC+1, Mikko wrote:
>> On 2022-06-30 18:30:10 +0000, olcott said:
>>
>>> On 6/30/2022 1:22 PM, Mikko wrote:
>>>> On 2022-06-29 13:00:16 +0000, olcott said:
>>>>
>>>>> IT IS THIS SIMPLE PRINCIPLE THAT REFUTES THE HALTING PROBLEM PROOFS:
>>>>> Every simulating halt decider correctly simulates its input until it
>>>>> correctly determines that this simulated input would never reach its
>>>>> final state.
>>>>
>>>> That does not refute any halting problem proof. Instead, you should prove:
>>>> Some simulating halt decider correctly simulates its input until it
>>>> correctly determines that this simulated input would never reach its
>>>> final state.
>>>>
>>>> Mikko
>>>
>>> I do not see any material difference between the two.
>> For proofs the logical difference between "every" and "some" is more
>> important. In more formal logic ∀ and ∃ are used and they are very
>> different. A common vernacular term for ∀ is "every" or "for every"
>> but "all" or "for all" is also used and sometimes "each" or "for each".
>> For ∃ the vernacular term "some" is often used, or "there is" if one
>> wants to use a verb.
>>
>> The reason there is a logical difference is that there is a material
>> difference. This is best illustrated by an example. One of the
>> examples of Aristotle was unicorn, so we can use that, too. So, is
>> the sentence "Every unicorn is green" true? Yes, because there is
>> no unicorn that is not green. Is the sentence "Some unicorn is green" true?
>> No, it is false, because no green unicorn exists. So the sentences are
>> materially different. That material difference is the material difference
>> between "every" and "some" (more formally, btween ∀ and ∃) as there is
>> no other difference between the sentences.
>>
> I don't know about formal logic, but this doesn't make sense for natural
> language. Every unicorn has one horn, because a unicorn is a horse
> with one horn. But "every unicorn has two horns" is false, even though
> there are no unicorns.

FOL quantifiers specify different sets. Your example of "for all" seems
correct, depending on how we handle the case of a unicorn that has had
its horn removed. It is either a unicorn without a horn or has been
demoted to be a horse.

--
Copyright 2022 Pete Olcott

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

On 6/30/2022 6:17 PM, Dennis Bush wrote:
> On Thursday, June 30, 2022 at 7:11:01 PM UTC-4, olcott wrote:
>> On 6/30/2022 6:05 PM, Dennis Bush wrote:
>>> On Thursday, June 30, 2022 at 6:57:12 PM UTC-4, olcott wrote:
>>>> On 6/30/2022 5:26 PM, Dennis Bush wrote:
>>>>> On Thursday, June 30, 2022 at 6:23:56 PM UTC-4, olcott wrote:
>>>>>> On 6/30/2022 5:09 PM, Dennis Bush wrote:
>>>>>>> On Thursday, June 30, 2022 at 5:52:37 PM UTC-4, olcott wrote:
>>>>>>>> On 6/30/2022 3:50 PM, Dennis Bush wrote:
>>>>>>>>> On Thursday, June 30, 2022 at 4:22:57 PM UTC-4, olcott wrote:
>>>>>>>>>> On 6/30/2022 11:55 AM, Dennis Bush wrote:
>>>>>>>>>>> On Thursday, June 30, 2022 at 12:43:17 PM UTC-4, olcott wrote:
>>>>>>>>>>>> On 6/30/2022 11:34 AM, Dennis Bush wrote:
>>>>>>>>>>>>> On Thursday, June 30, 2022 at 12:15:58 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>> On 6/30/2022 10:40 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Thursday, June 30, 2022 at 11:36:43 AM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>> On 6/30/2022 7:12 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>> On Thursday, June 30, 2022 at 12:59:38 AM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>> On 6/29/2022 11:51 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>> On Thursday, June 30, 2022 at 12:42:59 AM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 6/29/2022 9:02 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>> On Wednesday, June 29, 2022 at 9:44:39 AM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 6/28/2022 8:44 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Every simulating halt decider correctly simulates its input until it
>>>>>>>>>>>>>>>>>>>>>> correctly determines that this simulated input would never reach its
>>>>>>>>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>>>>>>>>>> I don't know why you keep making the ridiculous assertion that a
>>>>>>>>>>>>>>>>>>>>>> simulating halt decider cannot possibly predict/determine that its
>>>>>>>>>>>>>>>>>>>>>> complete and correct x86 emulation of its input would never reach the
>>>>>>>>>>>>>>>>>>>>>> "ret" instruction of this input.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> But Ha doesn't *do* a complete and correct emulation of its input as per its fixed algorithm, so to say what the complete and correct emulation of the input to Ha(Pa,Pa) by Ha is, is simply nonsense.
>>>>>>>>>>>>>>>>>>>> To continue to insist that a simulating halt decider cannot correctly
>>>>>>>>>>>>>>>>>>>> predict (in a finite number of steps) that its complete and correct x86
>>>>>>>>>>>>>>>>>>>> emulation of its input
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Which does not exist because Ha aborts and therefore does not do a complete and correct x86 emulation.
>>>>>>>>>>>>>>>>>> We are taking that what you are saying means that you believe it is
>>>>>>>>>>>>>>>>>> impossible for H to correctly determine that Infinite_Loop() never halts.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No, you're saying that the correctness criteria for Ha(Pa,Pa) is a complete and correct emulation of the input *by Ha*. And because Ha has a fixed algorithm that aborts, Ha does not do a complete and correct emulation of the input.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> And because Ha does not do a complete and correct emulation of the input, what I'm saying is that your correctness criteria simply doesn't exist.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> That is a Jackass (deceptive head games) thing to say when you already
>>>>>>>>>>>>>>>> know that H merely needs to correctly predict what the complete and
>>>>>>>>>>>>>>>> correct x86 emulation of its input would do and it need not actually to
>>>>>>>>>>>>>>>> a complete emulation to do this. EXAMPLE BELOW
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *The* complete and correct emulation of the input to Ha(Pa,Pa) is performed by UTM(Pa,Pa) which halts, proving that Ha(Pa,Pa)==0 is wrong.
>>>>>>>>>>>>>> The part that you keep erasing proves that you are a liar.
>>>>>>>>>>>>>> You keep erasing it because you know that it proves you are a liar.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Infinite_Loop was previously shown to be irrelevant.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Changing the subject to a completely different computation UTM(Pa,Pa)
>>>>>>>>>>>>>> than the actual computation Ha(Pa,Pa) is the strawman deception.
>>>>>>>>>>>>>> straw man
>>>>>>>>>>>>>> An intentionally misrepresented proposition that is set up because it is
>>>>>>>>>>>>>> easier to defeat than an opponent's real argument.
>>>>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
>>>>>>>>>>>>>
>>>>>>>>>>>>> I'm not changing the subject. I'm just going by what you're saying.
>>>>>>>>>>>>>
>>>>>>>>>>>>>> THIS IS NECESSARILY TRUE THUS IMPOSSIBLY FALSE
>>>>>>>>>>>>>> Every simulating halt decider correctly simulates its input until it
>>>>>>>>>>>>>> correctly determines that this simulated input would never reach its
>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You keep changing this part. Sometimes you say "the" simulated input, sometimes "its" simulated input, sometimes "this" simulated input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> *The* complete and correct simulation of the input to Ha(Pa,Pa) is by definition performed by UTM(Pa,Pa).
>>>>>>>>>>>> That is a lie and you know it.
>>>>>>>>>>>>
>>>>>>>>>>>> The actual behavior of the actual input to H(P,P) is conclusively proven
>>>>>>>>>>>> to diverge from the actual behavior of the actual input to H1(P,P) on
>>>>>>>>>>>> the basis of the semantics of the x86 language.
>>>>>>>>>>>
>>>>>>>>>>> Then what is the first x86 instruction where the behavior of Ha(Pa,Pa) and UTM(Pa,Pa) differ?
>>>>>>>>>>>
>>>>>>>>>> [0000164a][00212749][0021274d] 83c408 add esp,+08
>>>>>>>>>
>>>>>>>>> FALSE
>>>>>>>>>
>>>>>>>>> The simulation performed by Ha is aborted before that instruction can be reached.
>>>>>>>> Aborted or not the above instruction is the first instruction that
>>>>>>>> differs.
>>>>>>>
>>>>>>> That instruction doesn't differ between the two simulations because Ha stopped before it got there.
>>>>>> Perhaps you are simply not bright enough to understand that aborted or
>>>>>> not the emulated input never reaches its "ret" instruction.
>>>>>
>>>>> Then you believe that Ha3(N,5)==0 is correct because the emulated input never reaches its "ret" instruction, correct?
>>>>>
>>>>> If not, then explain in detail why it is wrong. Failure to do so will be taken as you asserting that this is correct.
>>>> The problem is not that you are not bright enough the problem is that
>>>> you are a liar that continues to try and get away with the strawman
>>>> deception.
>>>
>>> You said "aborted or not the emulated input never reaches its "ret" instruction". There is no "not" since the fixed algorithm of Ha aborts, so you're saying that because Ha aborts that causes the "ret" instruction to not be reached which is your criteria for returning 0.
>> *This is necessarily true thus impossibly false*
>> Every simulating halt decider that correctly simulates its input until
>> it correctly determines that this simulated input would never reach its
>> final state, correctly rejects this input as non-halting.
>
> So now you're back to "this" simulated input, which means aborting and reporting non-halting is necessarily correct.
>
> Which means you've just affirmed that you agree that Ha3(N,5)==0 is correct.

On Friday, July 1, 2022 at 8:55:01 AM UTC-4, olcott wrote:
> On 6/30/2022 6:17 PM, Dennis Bush wrote:
> > On Thursday, June 30, 2022 at 7:11:01 PM UTC-4, olcott wrote:
> >> On 6/30/2022 6:05 PM, Dennis Bush wrote:
> >>> On Thursday, June 30, 2022 at 6:57:12 PM UTC-4, olcott wrote:
> >>>> On 6/30/2022 5:26 PM, Dennis Bush wrote:
> >>>>> On Thursday, June 30, 2022 at 6:23:56 PM UTC-4, olcott wrote:
> >>>>>> On 6/30/2022 5:09 PM, Dennis Bush wrote:
> >>>>>>> On Thursday, June 30, 2022 at 5:52:37 PM UTC-4, olcott wrote:
> >>>>>>>> On 6/30/2022 3:50 PM, Dennis Bush wrote:
> >>>>>>>>> On Thursday, June 30, 2022 at 4:22:57 PM UTC-4, olcott wrote:
> >>>>>>>>>> On 6/30/2022 11:55 AM, Dennis Bush wrote:
> >>>>>>>>>>> On Thursday, June 30, 2022 at 12:43:17 PM UTC-4, olcott wrote:
> >>>>>>>>>>>> On 6/30/2022 11:34 AM, Dennis Bush wrote:
> >>>>>>>>>>>>> On Thursday, June 30, 2022 at 12:15:58 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>> On 6/30/2022 10:40 AM, Dennis Bush wrote:
> >>>>>>>>>>>>>>> On Thursday, June 30, 2022 at 11:36:43 AM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>> On 6/30/2022 7:12 AM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>> On Thursday, June 30, 2022 at 12:59:38 AM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>> On 6/29/2022 11:51 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>> On Thursday, June 30, 2022 at 12:42:59 AM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>> On 6/29/2022 9:02 AM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>>>> On Wednesday, June 29, 2022 at 9:44:39 AM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>> On 6/28/2022 8:44 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> Every simulating halt decider correctly simulates its input until it
> >>>>>>>>>>>>>>>>>>>>>> correctly determines that this simulated input would never reach its
> >>>>>>>>>>>>>>>>>>>>>> final state.
> >>>>>>>>>>>>>>>>>>>>>> I don't know why you keep making the ridiculous assertion that a
> >>>>>>>>>>>>>>>>>>>>>> simulating halt decider cannot possibly predict/determine that its
> >>>>>>>>>>>>>>>>>>>>>> complete and correct x86 emulation of its input would never reach the
> >>>>>>>>>>>>>>>>>>>>>> "ret" instruction of this input.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> But Ha doesn't *do* a complete and correct emulation of its input as per its fixed algorithm, so to say what the complete and correct emulation of the input to Ha(Pa,Pa) by Ha is, is simply nonsense.
> >>>>>>>>>>>>>>>>>>>> To continue to insist that a simulating halt decider cannot correctly
> >>>>>>>>>>>>>>>>>>>> predict (in a finite number of steps) that its complete and correct x86
> >>>>>>>>>>>>>>>>>>>> emulation of its input
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> Which does not exist because Ha aborts and therefore does not do a complete and correct x86 emulation.
> >>>>>>>>>>>>>>>>>> We are taking that what you are saying means that you believe it is
> >>>>>>>>>>>>>>>>>> impossible for H to correctly determine that Infinite_Loop() never halts.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> No, you're saying that the correctness criteria for Ha(Pa,Pa) is a complete and correct emulation of the input *by Ha*. And because Ha has a fixed algorithm that aborts, Ha does not do a complete and correct emulation of the input.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> And because Ha does not do a complete and correct emulation of the input, what I'm saying is that your correctness criteria simply doesn't exist.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> That is a Jackass (deceptive head games) thing to say when you already
> >>>>>>>>>>>>>>>> know that H merely needs to correctly predict what the complete and
> >>>>>>>>>>>>>>>> correct x86 emulation of its input would do and it need not actually to
> >>>>>>>>>>>>>>>> a complete emulation to do this. EXAMPLE BELOW
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> *The* complete and correct emulation of the input to Ha(Pa,Pa) is performed by UTM(Pa,Pa) which halts, proving that Ha(Pa,Pa)==0 is wrong.
> >>>>>>>>>>>>>> The part that you keep erasing proves that you are a liar.
> >>>>>>>>>>>>>> You keep erasing it because you know that it proves you are a liar.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Infinite_Loop was previously shown to be irrelevant.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Changing the subject to a completely different computation UTM(Pa,Pa)
> >>>>>>>>>>>>>> than the actual computation Ha(Pa,Pa) is the strawman deception.
> >>>>>>>>>>>>>> straw man
> >>>>>>>>>>>>>> An intentionally misrepresented proposition that is set up because it is
> >>>>>>>>>>>>>> easier to defeat than an opponent's real argument.
> >>>>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> I'm not changing the subject. I'm just going by what you're saying.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>> THIS IS NECESSARILY TRUE THUS IMPOSSIBLY FALSE
> >>>>>>>>>>>>>> Every simulating halt decider correctly simulates its input until it
> >>>>>>>>>>>>>> correctly determines that this simulated input would never reach its
> >>>>>>>>>>>>>> final state.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> You keep changing this part. Sometimes you say "the" simulated input, sometimes "its" simulated input, sometimes "this" simulated input.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> *The* complete and correct simulation of the input to Ha(Pa,Pa) is by definition performed by UTM(Pa,Pa).
> >>>>>>>>>>>> That is a lie and you know it.
> >>>>>>>>>>>>
> >>>>>>>>>>>> The actual behavior of the actual input to H(P,P) is conclusively proven
> >>>>>>>>>>>> to diverge from the actual behavior of the actual input to H1(P,P) on
> >>>>>>>>>>>> the basis of the semantics of the x86 language.
> >>>>>>>>>>>
> >>>>>>>>>>> Then what is the first x86 instruction where the behavior of Ha(Pa,Pa) and UTM(Pa,Pa) differ?
> >>>>>>>>>>>
> >>>>>>>>>> [0000164a][00212749][0021274d] 83c408 add esp,+08
> >>>>>>>>>
> >>>>>>>>> FALSE
> >>>>>>>>>
> >>>>>>>>> The simulation performed by Ha is aborted before that instruction can be reached.
> >>>>>>>> Aborted or not the above instruction is the first instruction that
> >>>>>>>> differs.
> >>>>>>>
> >>>>>>> That instruction doesn't differ between the two simulations because Ha stopped before it got there.
> >>>>>> Perhaps you are simply not bright enough to understand that aborted or
> >>>>>> not the emulated input never reaches its "ret" instruction.
> >>>>>
> >>>>> Then you believe that Ha3(N,5)==0 is correct because the emulated input never reaches its "ret" instruction, correct?
> >>>>>
> >>>>> If not, then explain in detail why it is wrong. Failure to do so will be taken as you asserting that this is correct.
> >>>> The problem is not that you are not bright enough the problem is that
> >>>> you are a liar that continues to try and get away with the strawman
> >>>> deception.
> >>>
> >>> You said "aborted or not the emulated input never reaches its "ret" instruction". There is no "not" since the fixed algorithm of Ha aborts, so you're saying that because Ha aborts that causes the "ret" instruction to not be reached which is your criteria for returning 0.
> >> *This is necessarily true thus impossibly false*
> >> Every simulating halt decider that correctly simulates its input until
> >> it correctly determines that this simulated input would never reach its
> >> final state, correctly rejects this input as non-halting.
> >
> > So now you're back to "this" simulated input, which means aborting and reporting non-halting is necessarily correct.
> >
> > Which means you've just affirmed that you agree that Ha3(N,5)==0 is correct.
> A dog is an animal is correct thus anyone that disagrees is necessarily
> incorrect.
> *This is necessarily true thus impossibly false*
> Every simulating halt decider that correctly simulates its input until
> it correctly determines that this simulated input would never reach its
> final state,

On 7/1/2022 8:18 AM, Dennis Bush wrote:
> On Friday, July 1, 2022 at 8:55:01 AM UTC-4, olcott wrote:
>> On 6/30/2022 6:17 PM, Dennis Bush wrote:
>>> On Thursday, June 30, 2022 at 7:11:01 PM UTC-4, olcott wrote:
>>>> On 6/30/2022 6:05 PM, Dennis Bush wrote:
>>>>> On Thursday, June 30, 2022 at 6:57:12 PM UTC-4, olcott wrote:
>>>>>> On 6/30/2022 5:26 PM, Dennis Bush wrote:
>>>>>>> On Thursday, June 30, 2022 at 6:23:56 PM UTC-4, olcott wrote:
>>>>>>>> On 6/30/2022 5:09 PM, Dennis Bush wrote:
>>>>>>>>> On Thursday, June 30, 2022 at 5:52:37 PM UTC-4, olcott wrote:
>>>>>>>>>> On 6/30/2022 3:50 PM, Dennis Bush wrote:
>>>>>>>>>>> On Thursday, June 30, 2022 at 4:22:57 PM UTC-4, olcott wrote:
>>>>>>>>>>>> On 6/30/2022 11:55 AM, Dennis Bush wrote:
>>>>>>>>>>>>> On Thursday, June 30, 2022 at 12:43:17 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>> On 6/30/2022 11:34 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Thursday, June 30, 2022 at 12:15:58 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>> On 6/30/2022 10:40 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>> On Thursday, June 30, 2022 at 11:36:43 AM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>> On 6/30/2022 7:12 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>> On Thursday, June 30, 2022 at 12:59:38 AM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 6/29/2022 11:51 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>> On Thursday, June 30, 2022 at 12:42:59 AM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 6/29/2022 9:02 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, June 29, 2022 at 9:44:39 AM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 6/28/2022 8:44 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Every simulating halt decider correctly simulates its input until it
>>>>>>>>>>>>>>>>>>>>>>>> correctly determines that this simulated input would never reach its
>>>>>>>>>>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>>>>>>>>>>>> I don't know why you keep making the ridiculous assertion that a
>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider cannot possibly predict/determine that its
>>>>>>>>>>>>>>>>>>>>>>>> complete and correct x86 emulation of its input would never reach the
>>>>>>>>>>>>>>>>>>>>>>>> "ret" instruction of this input.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> But Ha doesn't *do* a complete and correct emulation of its input as per its fixed algorithm, so to say what the complete and correct emulation of the input to Ha(Pa,Pa) by Ha is, is simply nonsense.
>>>>>>>>>>>>>>>>>>>>>> To continue to insist that a simulating halt decider cannot correctly
>>>>>>>>>>>>>>>>>>>>>> predict (in a finite number of steps) that its complete and correct x86
>>>>>>>>>>>>>>>>>>>>>> emulation of its input
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Which does not exist because Ha aborts and therefore does not do a complete and correct x86 emulation.
>>>>>>>>>>>>>>>>>>>> We are taking that what you are saying means that you believe it is
>>>>>>>>>>>>>>>>>>>> impossible for H to correctly determine that Infinite_Loop() never halts.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No, you're saying that the correctness criteria for Ha(Pa,Pa) is a complete and correct emulation of the input *by Ha*. And because Ha has a fixed algorithm that aborts, Ha does not do a complete and correct emulation of the input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> And because Ha does not do a complete and correct emulation of the input, what I'm saying is that your correctness criteria simply doesn't exist.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> That is a Jackass (deceptive head games) thing to say when you already
>>>>>>>>>>>>>>>>>> know that H merely needs to correctly predict what the complete and
>>>>>>>>>>>>>>>>>> correct x86 emulation of its input would do and it need not actually to
>>>>>>>>>>>>>>>>>> a complete emulation to do this. EXAMPLE BELOW
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *The* complete and correct emulation of the input to Ha(Pa,Pa) is performed by UTM(Pa,Pa) which halts, proving that Ha(Pa,Pa)==0 is wrong.
>>>>>>>>>>>>>>>> The part that you keep erasing proves that you are a liar.
>>>>>>>>>>>>>>>> You keep erasing it because you know that it proves you are a liar.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Infinite_Loop was previously shown to be irrelevant.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Changing the subject to a completely different computation UTM(Pa,Pa)
>>>>>>>>>>>>>>>> than the actual computation Ha(Pa,Pa) is the strawman deception.
>>>>>>>>>>>>>>>> straw man
>>>>>>>>>>>>>>>> An intentionally misrepresented proposition that is set up because it is
>>>>>>>>>>>>>>>> easier to defeat than an opponent's real argument.
>>>>>>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I'm not changing the subject. I'm just going by what you're saying.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> THIS IS NECESSARILY TRUE THUS IMPOSSIBLY FALSE
>>>>>>>>>>>>>>>> Every simulating halt decider correctly simulates its input until it
>>>>>>>>>>>>>>>> correctly determines that this simulated input would never reach its
>>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You keep changing this part. Sometimes you say "the" simulated input, sometimes "its" simulated input, sometimes "this" simulated input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *The* complete and correct simulation of the input to Ha(Pa,Pa) is by definition performed by UTM(Pa,Pa).
>>>>>>>>>>>>>> That is a lie and you know it.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The actual behavior of the actual input to H(P,P) is conclusively proven
>>>>>>>>>>>>>> to diverge from the actual behavior of the actual input to H1(P,P) on
>>>>>>>>>>>>>> the basis of the semantics of the x86 language.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Then what is the first x86 instruction where the behavior of Ha(Pa,Pa) and UTM(Pa,Pa) differ?
>>>>>>>>>>>>>
>>>>>>>>>>>> [0000164a][00212749][0021274d] 83c408 add esp,+08
>>>>>>>>>>>
>>>>>>>>>>> FALSE
>>>>>>>>>>>
>>>>>>>>>>> The simulation performed by Ha is aborted before that instruction can be reached.
>>>>>>>>>> Aborted or not the above instruction is the first instruction that
>>>>>>>>>> differs.
>>>>>>>>>
>>>>>>>>> That instruction doesn't differ between the two simulations because Ha stopped before it got there.
>>>>>>>> Perhaps you are simply not bright enough to understand that aborted or
>>>>>>>> not the emulated input never reaches its "ret" instruction.
>>>>>>>
>>>>>>> Then you believe that Ha3(N,5)==0 is correct because the emulated input never reaches its "ret" instruction, correct?
>>>>>>>
>>>>>>> If not, then explain in detail why it is wrong. Failure to do so will be taken as you asserting that this is correct.
>>>>>> The problem is not that you are not bright enough the problem is that
>>>>>> you are a liar that continues to try and get away with the strawman
>>>>>> deception.
>>>>>
>>>>> You said "aborted or not the emulated input never reaches its "ret" instruction". There is no "not" since the fixed algorithm of Ha aborts, so you're saying that because Ha aborts that causes the "ret" instruction to not be reached which is your criteria for returning 0.
>>>> *This is necessarily true thus impossibly false*
>>>> Every simulating halt decider that correctly simulates its input until
>>>> it correctly determines that this simulated input would never reach its
>>>> final state, correctly rejects this input as non-halting.
>>>
>>> So now you're back to "this" simulated input, which means aborting and reporting non-halting is necessarily correct.
>>>
>>> Which means you've just affirmed that you agree that Ha3(N,5)==0 is correct.
>> A dog is an animal is correct thus anyone that disagrees is necessarily
>> incorrect.
>> *This is necessarily true thus impossibly false*
>> Every simulating halt decider that correctly simulates its input until
>> it correctly determines that this simulated input would never reach its
>> final state,
>
> In other words, for Ha(Pa,Pa) the fixed algorithm of Ha determines if it is able to simulate its input to a final state. It cannot, so you assert that Ha(Pa,Pa)==0 is correct.

Demented bigot and crank Peter Olcott wrote:
> On 7/1/2022 8:18 AM, Dennis Bush wrote:
....
>> In other words, for Ha(Pa,Pa) the fixed algorithm of Ha determines if
>> it is able to simulate its input to a final state.  It cannot, so you
>> assert that Ha(Pa,Pa)==0 is correct.
>
> It is not that Ha(Pa,Pa) does not have the ability to simulate its input
> until its input reaches a final state it is the fact that P is calling H
> in infinite recursion that prevents P from ever reaching its final
> state. H sees this and rejects P as non-halting.
>
> _Infinite_Loop()
> [00001102](01)  55         push ebp
> [00001103](02)  8bec       mov ebp,esp
> [00001105](02)  ebfe       jmp 00001105
> [00001107](01)  5d         pop ebp
> [00001108](01)  c3         ret
> Size in bytes:(0007) [00001108]
>
> It is not that H0(_Infinite_Loop) does not have the ability to simulate
> its input until its input reaches a final state it is the fact that
> _Infinite_Loop species an infinite loop that prevents _Infinite_Loop
> from ever reaching its final state. H sees this and rejects
> _Infinite_Loop as non-halting.
>
>

Peter, your sophistry and your imbecility are boring.

Could you please die soon?

On Friday, July 1, 2022 at 9:38:06 AM UTC-4, olcott wrote:
> On 7/1/2022 8:18 AM, Dennis Bush wrote:
> > On Friday, July 1, 2022 at 8:55:01 AM UTC-4, olcott wrote:
> >> On 6/30/2022 6:17 PM, Dennis Bush wrote:
> >>> On Thursday, June 30, 2022 at 7:11:01 PM UTC-4, olcott wrote:
> >>>> On 6/30/2022 6:05 PM, Dennis Bush wrote:
> >>>>> On Thursday, June 30, 2022 at 6:57:12 PM UTC-4, olcott wrote:
> >>>>>> On 6/30/2022 5:26 PM, Dennis Bush wrote:
> >>>>>>> On Thursday, June 30, 2022 at 6:23:56 PM UTC-4, olcott wrote:
> >>>>>>>> On 6/30/2022 5:09 PM, Dennis Bush wrote:

> >>>>>>>> Perhaps you are simply not bright enough to understand that aborted or
> >>>>>>>> not the emulated input never reaches its "ret" instruction.
> >>>>>>>
> >>>>>>> Then you believe that Ha3(N,5)==0 is correct because the emulated input never reaches its "ret" instruction, correct?
> >>>>>>>
> >>>>>>> If not, then explain in detail why it is wrong. Failure to do so will be taken as you asserting that this is correct.
> >>>>>> The problem is not that you are not bright enough the problem is that
> >>>>>> you are a liar that continues to try and get away with the strawman
> >>>>>> deception.
> >>>>>
> >>>>> You said "aborted or not the emulated input never reaches its "ret" instruction". There is no "not" since the fixed algorithm of Ha aborts, so you're saying that because Ha aborts that causes the "ret" instruction to not be reached which is your criteria for returning 0.
> >>>> *This is necessarily true thus impossibly false*
> >>>> Every simulating halt decider that correctly simulates its input until
> >>>> it correctly determines that this simulated input would never reach its
> >>>> final state, correctly rejects this input as non-halting.
> >>>
> >>> So now you're back to "this" simulated input, which means aborting and reporting non-halting is necessarily correct.
> >>>
> >>> Which means you've just affirmed that you agree that Ha3(N,5)==0 is correct.
> >> A dog is an animal is correct thus anyone that disagrees is necessarily
> >> incorrect.
> >> *This is necessarily true thus impossibly false*
> >> Every simulating halt decider that correctly simulates its input until
> >> it correctly determines that this simulated input would never reach its
> >> final state,
> >
> > In other words, for Ha(Pa,Pa) the fixed algorithm of Ha determines if it is able to simulate its input to a final state. It cannot, so you assert that Ha(Pa,Pa)==0 is correct.
> It is not that Ha(Pa,Pa) does not have the ability to simulate its input
> until its input reaches a final state it is the fact that P is calling H
> in infinite recursion that prevents P from ever reaching its final
> state. H sees this and rejects P as non-halting.

Pa is not calling Ha in infinite recursion. Since Ha is a pure function of its inputs (or at least it should be), Ha(Pa,Pa) will *always* return 0 in all contexts. So a correct simulation of Pa will correctly simulate the call to Ha which aborts *its* internal simulation, breaking the cycle, and will return 0, which causes the simulated Pa to halt.

This proves that Ha(Pa,Pa)==0 is wrong.

>
> _Infinite_Loop()
> [00001102](01) 55 push ebp
> [00001103](02) 8bec mov ebp,esp
> [00001105](02) ebfe jmp 00001105
> [00001107](01) 5d pop ebp
> [00001108](01) c3 ret
> Size in bytes:(0007) [00001108]
>
> It is not that H0(_Infinite_Loop) does not have the ability to simulate
> its input until its input reaches a final state it is the fact that
> _Infinite_Loop species an infinite loop that prevents _Infinite_Loop
> from ever reaching its final state.

Which can be seen in an actual complete simulation, i.e. UTM(_Infinite_Loop), which dictates that returning 0 is correct.

> H sees this and rejects
> _Infinite_Loop as non-halting.
> --
> Copyright 2022 Pete Olcott

On 7/1/2022 8:40 AM, Python wrote:
> Demented bigot and crank Peter Olcott wrote:
>> On 7/1/2022 8:18 AM, Dennis Bush wrote:
> ...
>>> In other words, for Ha(Pa,Pa) the fixed algorithm of Ha determines if
>>> it is able to simulate its input to a final state.  It cannot, so you
>>> assert that Ha(Pa,Pa)==0 is correct.
>>
>> It is not that Ha(Pa,Pa) does not have the ability to simulate its
>> input until its input reaches a final state it is the fact that P is
>> calling H in infinite recursion that prevents P from ever reaching its
>> final state. H sees this and rejects P as non-halting.
>>
>> _Infinite_Loop()
>> [00001102](01)  55         push ebp
>> [00001103](02)  8bec       mov ebp,esp
>> [00001105](02)  ebfe       jmp 00001105
>> [00001107](01)  5d         pop ebp
>> [00001108](01)  c3         ret
>> Size in bytes:(0007) [00001108]
>>
>> It is not that H0(_Infinite_Loop) does not have the ability to
>> simulate its input until its input reaches a final state it is the
>> fact that _Infinite_Loop species an infinite loop that prevents
>> _Infinite_Loop from ever reaching its final state. H sees this and
>> rejects _Infinite_Loop as non-halting.
>>
>>
>
> Peter, your sophistry and your imbecility are boring.
>
> Could you please die soon?

Karma back at you.

--
Copyright 2022 Pete Olcott

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

On 7/1/2022 8:50 AM, Dennis Bush wrote:
> On Friday, July 1, 2022 at 9:38:06 AM UTC-4, olcott wrote:
>> On 7/1/2022 8:18 AM, Dennis Bush wrote:
>>> On Friday, July 1, 2022 at 8:55:01 AM UTC-4, olcott wrote:
>>>> On 6/30/2022 6:17 PM, Dennis Bush wrote:
>>>>> On Thursday, June 30, 2022 at 7:11:01 PM UTC-4, olcott wrote:
>>>>>> On 6/30/2022 6:05 PM, Dennis Bush wrote:
>>>>>>> On Thursday, June 30, 2022 at 6:57:12 PM UTC-4, olcott wrote:
>>>>>>>> On 6/30/2022 5:26 PM, Dennis Bush wrote:
>>>>>>>>> On Thursday, June 30, 2022 at 6:23:56 PM UTC-4, olcott wrote:
>>>>>>>>>> On 6/30/2022 5:09 PM, Dennis Bush wrote:
>
>>>>>>>>>> Perhaps you are simply not bright enough to understand that aborted or
>>>>>>>>>> not the emulated input never reaches its "ret" instruction.
>>>>>>>>>
>>>>>>>>> Then you believe that Ha3(N,5)==0 is correct because the emulated input never reaches its "ret" instruction, correct?
>>>>>>>>>
>>>>>>>>> If not, then explain in detail why it is wrong. Failure to do so will be taken as you asserting that this is correct.
>>>>>>>> The problem is not that you are not bright enough the problem is that
>>>>>>>> you are a liar that continues to try and get away with the strawman
>>>>>>>> deception.
>>>>>>>
>>>>>>> You said "aborted or not the emulated input never reaches its "ret" instruction". There is no "not" since the fixed algorithm of Ha aborts, so you're saying that because Ha aborts that causes the "ret" instruction to not be reached which is your criteria for returning 0.
>>>>>> *This is necessarily true thus impossibly false*
>>>>>> Every simulating halt decider that correctly simulates its input until
>>>>>> it correctly determines that this simulated input would never reach its
>>>>>> final state, correctly rejects this input as non-halting.
>>>>>
>>>>> So now you're back to "this" simulated input, which means aborting and reporting non-halting is necessarily correct.
>>>>>
>>>>> Which means you've just affirmed that you agree that Ha3(N,5)==0 is correct.
>>>> A dog is an animal is correct thus anyone that disagrees is necessarily
>>>> incorrect.
>>>> *This is necessarily true thus impossibly false*
>>>> Every simulating halt decider that correctly simulates its input until
>>>> it correctly determines that this simulated input would never reach its
>>>> final state,
>>>
>>> In other words, for Ha(Pa,Pa) the fixed algorithm of Ha determines if it is able to simulate its input to a final state. It cannot, so you assert that Ha(Pa,Pa)==0 is correct.
>> It is not that Ha(Pa,Pa) does not have the ability to simulate its input
>> until its input reaches a final state it is the fact that P is calling H
>> in infinite recursion that prevents P from ever reaching its final
>> state. H sees this and rejects P as non-halting.
>
> Pa is not calling Ha in infinite recursion. Since Ha is a pure function of its inputs (or at least it should be), Ha(Pa,Pa) will *always* return 0 in all contexts.

*This is necessarily true thus impossibly false*
Every simulating halt decider that correctly simulates its input until
it correctly determines that this simulated input would never reach its
final state, correctly rejects this input as non-halting.

People that disagree with verified facts are either stupid or liars and
you are not stupid.

> So a correct simulation of Pa will correctly simulate the call to Ha which aborts *its* internal simulation, breaking the cycle, and will return 0, which causes the simulated Pa to halt.
>
> This proves that Ha(Pa,Pa)==0 is wrong.
>
>>
>> _Infinite_Loop()
>> [00001102](01) 55 push ebp
>> [00001103](02) 8bec mov ebp,esp
>> [00001105](02) ebfe jmp 00001105
>> [00001107](01) 5d pop ebp
>> [00001108](01) c3 ret
>> Size in bytes:(0007) [00001108]
>>
>> It is not that H0(_Infinite_Loop) does not have the ability to simulate
>> its input until its input reaches a final state it is the fact that
>> _Infinite_Loop species an infinite loop that prevents _Infinite_Loop
>> from ever reaching its final state.
>
> Which can be seen in an actual complete simulation, i.e. UTM(_Infinite_Loop), which dictates that returning 0 is correct.
>

int Simulate(u32 P, u32 I)
{ ((int(*)(int))P)(I);
return 1;
}

void Px(u32 x)
{ if (Simulate(x, x))
HERE: goto HERE;
return;
}

int main()
{ Output("Input_Halts = ", H((u32)Px, (u32)Px));
}

_Simulate()
[00001152](01) 55 push ebp
[00001153](02) 8bec mov ebp,esp
[00001155](03) 8b450c mov eax,[ebp+0c]
[00001158](01) 50 push eax
[00001159](03) ff5508 call dword [ebp+08]
[0000115c](03) 83c404 add esp,+04
[0000115f](05) b801000000 mov eax,00000001
[00001164](01) 5d pop ebp
[00001165](01) c3 ret
Size in bytes:(0020) [00001165]

_Px()
[00001172](01) 55 push ebp
[00001173](02) 8bec mov ebp,esp
[00001175](03) 8b4508 mov eax,[ebp+08]
[00001178](01) 50 push eax
[00001179](03) 8b4d08 mov ecx,[ebp+08]
[0000117c](01) 51 push ecx
[0000117d](05) e8d0ffffff call 00001152
[00001182](03) 83c408 add esp,+08
[00001185](02) 85c0 test eax,eax
[00001187](02) 7402 jz 0000118b
[00001189](02) ebfe jmp 00001189
[0000118b](01) 5d pop ebp
[0000118c](01) c3 ret
Size in bytes:(0027) [0000118c]

_main()
[000011b2](01) 55 push ebp
[000011b3](02) 8bec mov ebp,esp
[000011b5](05) 6872110000 push 00001172
[000011ba](05) 6872110000 push 00001172
[000011bf](05) e8aefdffff call 00000f72
[000011c4](03) 83c408 add esp,+08
[000011c7](01) 50 push eax
[000011c8](05) 68a3040000 push 000004a3
[000011cd](05) e820f3ffff call 000004f2
[000011d2](03) 83c408 add esp,+08
[000011d5](02) 33c0 xor eax,eax
[000011d7](01) 5d pop ebp
[000011d8](01) c3 ret
Size in bytes:(0039) [000011d8]

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[000011b2][00101f43][00000000] 55 push ebp
[000011b3][00101f43][00000000] 8bec mov ebp,esp
[000011b5][00101f3f][00001172] 6872110000 push 00001172
[000011ba][00101f3b][00001172] 6872110000 push 00001172
[000011bf][00101f37][000011c4] e8aefdffff call 00000f72

H: Begin Simulation Execution Trace Stored at:211ff7
Address_of_H:f72
[00001172][00211fe3][00211fe7] 55 push ebp
[00001173][00211fe3][00211fe7] 8bec mov ebp,esp
[00001175][00211fe3][00211fe7] 8b4508 mov eax,[ebp+08]
[00001178][00211fdf][00001172] 50 push eax
[00001179][00211fdf][00001172] 8b4d08 mov ecx,[ebp+08]
[0000117c][00211fdb][00001172] 51 push ecx
[0000117d][00211fd7][00001182] e8d0ffffff call 00001152
[00001152][00211fd3][00211fe3] 55 push ebp
[00001153][00211fd3][00211fe3] 8bec mov ebp,esp
[00001155][00211fd3][00211fe3] 8b450c mov eax,[ebp+0c]
[00001158][00211fcf][00001172] 50 push eax
Calling:_Px()
Decode_Control_Flow_Instruction([00000008][00211fd3][00001172])
[00001159][00211fcb][0000115c] ff5508 call dword [ebp+08]
[00001172][00211fc7][00211fd3] 55 push ebp
[00001173][00211fc7][00211fd3] 8bec mov ebp,esp
[00001175][00211fc7][00211fd3] 8b4508 mov eax,[ebp+08]
[00001178][00211fc3][00001172] 50 push eax
[00001179][00211fc3][00001172] 8b4d08 mov ecx,[ebp+08]
[0000117c][00211fbf][00001172] 51 push ecx
[0000117d][00211fbb][00001182] e8d0ffffff call 00001152
H: Infinite Recursion Detected Simulation Stopped

[000011c4][00101f43][00000000] 83c408 add esp,+08
[000011c7][00101f3f][00000000] 50 push eax
[000011c8][00101f3b][000004a3] 68a3040000 push 000004a3
[000011cd][00101f3b][000004a3] e820f3ffff call 000004f2
Input_Halts = 0
[000011d2][00101f43][00000000] 83c408 add esp,+08
[000011d5][00101f43][00000000] 33c0 xor eax,eax
[000011d7][00101f47][00100000] 5d pop ebp
[000011d8][00101f4b][00000000] c3 ret
Number of Instructions Executed(2202) == 33 Pages

>> H sees this and rejects
>> _Infinite_Loop as non-halting.
>> --
>> Copyright 2022 Pete Olcott

--
Copyright 2022 Pete Olcott

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

Demented uncompetent kook Peter Olcott wrote:
> [pathetic evading idiocies]

0x8054 <_start> mov r0, pc
0x8058 <_start+4> mov r0, #2
0x805c <_start+8> add r1, r0, r0
0x8060 <_start+12> bkpt 0x0000
0x8064 andeq r1, r0, r1, asr #10
0x8068 cmnvs r5, r0, lsl #2
0x806c tsteq r0, r2, ror #18
0x8070 andeq r0, r0, r11
0x8074 tsteq r8, r6, lsl #6

Le 01/07/2022 à 16:10, olcott a écrit :
> On 7/1/2022 8:40 AM, Python wrote:
>> Demented bigot and crank Peter Olcott wrote:
>>> On 7/1/2022 8:18 AM, Dennis Bush wrote:
>> ...
>>>> In other words, for Ha(Pa,Pa) the fixed algorithm of Ha determines
>>>> if it is able to simulate its input to a final state.  It cannot, so
>>>> you assert that Ha(Pa,Pa)==0 is correct.
>>>
>>> It is not that Ha(Pa,Pa) does not have the ability to simulate its
>>> input until its input reaches a final state it is the fact that P is
>>> calling H in infinite recursion that prevents P from ever reaching
>>> its final state. H sees this and rejects P as non-halting.
>>>
>>> _Infinite_Loop()
>>> [00001102](01)  55         push ebp
>>> [00001103](02)  8bec       mov ebp,esp
>>> [00001105](02)  ebfe       jmp 00001105
>>> [00001107](01)  5d         pop ebp
>>> [00001108](01)  c3         ret
>>> Size in bytes:(0007) [00001108]
>>>
>>> It is not that H0(_Infinite_Loop) does not have the ability to
>>> simulate its input until its input reaches a final state it is the
>>> fact that _Infinite_Loop species an infinite loop that prevents
>>> _Infinite_Loop from ever reaching its final state. H sees this and
>>> rejects _Infinite_Loop as non-halting.
>>>
>>>
>>
>> Peter, your sophistry and your imbecility are boring.
>>
>> Could you please die soon?
>
> Karma back at you.

You got cancer, Peter, right? Did you consider that this punishment
in *your* karma is likely to be sent to you by GOD himself? For most
of your abusive conducts in your miserable life.

On Friday, July 1, 2022 at 10:22:48 AM UTC-4, olcott wrote:
> On 7/1/2022 8:50 AM, Dennis Bush wrote:
> > On Friday, July 1, 2022 at 9:38:06 AM UTC-4, olcott wrote:
> >> On 7/1/2022 8:18 AM, Dennis Bush wrote:
> >>> On Friday, July 1, 2022 at 8:55:01 AM UTC-4, olcott wrote:
> >>>> On 6/30/2022 6:17 PM, Dennis Bush wrote:
> >>>>> On Thursday, June 30, 2022 at 7:11:01 PM UTC-4, olcott wrote:
> >>>>>> On 6/30/2022 6:05 PM, Dennis Bush wrote:
> >>>>>>> On Thursday, June 30, 2022 at 6:57:12 PM UTC-4, olcott wrote:
> >>>>>>>> On 6/30/2022 5:26 PM, Dennis Bush wrote:
> >>>>>>>>> On Thursday, June 30, 2022 at 6:23:56 PM UTC-4, olcott wrote:
> >>>>>>>>>> On 6/30/2022 5:09 PM, Dennis Bush wrote:
> >
> >>>>>>>>>> Perhaps you are simply not bright enough to understand that aborted or
> >>>>>>>>>> not the emulated input never reaches its "ret" instruction.
> >>>>>>>>>
> >>>>>>>>> Then you believe that Ha3(N,5)==0 is correct because the emulated input never reaches its "ret" instruction, correct?
> >>>>>>>>>
> >>>>>>>>> If not, then explain in detail why it is wrong. Failure to do so will be taken as you asserting that this is correct.
> >>>>>>>> The problem is not that you are not bright enough the problem is that
> >>>>>>>> you are a liar that continues to try and get away with the strawman
> >>>>>>>> deception.
> >>>>>>>
> >>>>>>> You said "aborted or not the emulated input never reaches its "ret" instruction". There is no "not" since the fixed algorithm of Ha aborts, so you're saying that because Ha aborts that causes the "ret" instruction to not be reached which is your criteria for returning 0.
> >>>>>> *This is necessarily true thus impossibly false*
> >>>>>> Every simulating halt decider that correctly simulates its input until
> >>>>>> it correctly determines that this simulated input would never reach its
> >>>>>> final state, correctly rejects this input as non-halting.
> >>>>>
> >>>>> So now you're back to "this" simulated input, which means aborting and reporting non-halting is necessarily correct.
> >>>>>
> >>>>> Which means you've just affirmed that you agree that Ha3(N,5)==0 is correct.
> >>>> A dog is an animal is correct thus anyone that disagrees is necessarily
> >>>> incorrect.
> >>>> *This is necessarily true thus impossibly false*
> >>>> Every simulating halt decider that correctly simulates its input until
> >>>> it correctly determines that this simulated input would never reach its
> >>>> final state,
> >>>
> >>> In other words, for Ha(Pa,Pa) the fixed algorithm of Ha determines if it is able to simulate its input to a final state. It cannot, so you assert that Ha(Pa,Pa)==0 is correct.
> >> It is not that Ha(Pa,Pa) does not have the ability to simulate its input
> >> until its input reaches a final state it is the fact that P is calling H
> >> in infinite recursion that prevents P from ever reaching its final
> >> state. H sees this and rejects P as non-halting.
> >
> > Pa is not calling Ha in infinite recursion. Since Ha is a pure function of its inputs (or at least it should be), Ha(Pa,Pa) will *always* return 0 in all contexts.
>
> *This is necessarily true thus impossibly false*
> Every simulating halt decider that correctly simulates its input until
> it correctly determines that this simulated input would never reach its
> final state, correctly rejects this input as non-halting.

So you're just repeating your original point instead of stating why I'm wrong, which means you have no rebuttal.

> People that disagree with verified facts are either stupid or liars and
> you are not stupid.
> > So a correct simulation of Pa will correctly simulate the call to Ha which aborts *its* internal simulation, breaking the cycle, and will return 0, which causes the simulated Pa to halt.
> >
> > This proves that Ha(Pa,Pa)==0 is wrong.
> >
> >>
> >> _Infinite_Loop()
> >> [00001102](01) 55 push ebp
> >> [00001103](02) 8bec mov ebp,esp
> >> [00001105](02) ebfe jmp 00001105
> >> [00001107](01) 5d pop ebp
> >> [00001108](01) c3 ret
> >> Size in bytes:(0007) [00001108]
> >>
> >> It is not that H0(_Infinite_Loop) does not have the ability to simulate
> >> its input until its input reaches a final state it is the fact that
> >> _Infinite_Loop species an infinite loop that prevents _Infinite_Loop
> >> from ever reaching its final state.
> >
> > Which can be seen in an actual complete simulation, i.e. UTM(_Infinite_Loop), which dictates that returning 0 is correct.
> >
> int Simulate(u32 P, u32 I)
> {
> ((int(*)(int))P)(I);
> return 1;
> }
>
> void Px(u32 x)
> {
> if (Simulate(x, x))
> HERE: goto HERE;
> return;
> }
>
> int main()
> {
> Output("Input_Halts = ", H((u32)Px, (u32)Px));
> }
>
> _Simulate()
> [00001152](01) 55 push ebp
> [00001153](02) 8bec mov ebp,esp
> [00001155](03) 8b450c mov eax,[ebp+0c]
> [00001158](01) 50 push eax
> [00001159](03) ff5508 call dword [ebp+08]
> [0000115c](03) 83c404 add esp,+04
> [0000115f](05) b801000000 mov eax,00000001
> [00001164](01) 5d pop ebp
> [00001165](01) c3 ret
> Size in bytes:(0020) [00001165]
>
> _Px()
> [00001172](01) 55 push ebp
> [00001173](02) 8bec mov ebp,esp
> [00001175](03) 8b4508 mov eax,[ebp+08]
> [00001178](01) 50 push eax
> [00001179](03) 8b4d08 mov ecx,[ebp+08]
> [0000117c](01) 51 push ecx
> [0000117d](05) e8d0ffffff call 00001152
> [00001182](03) 83c408 add esp,+08
> [00001185](02) 85c0 test eax,eax
> [00001187](02) 7402 jz 0000118b
> [00001189](02) ebfe jmp 00001189
> [0000118b](01) 5d pop ebp
> [0000118c](01) c3 ret
> Size in bytes:(0027) [0000118c]
>
> _main()
> [000011b2](01) 55 push ebp
> [000011b3](02) 8bec mov ebp,esp
> [000011b5](05) 6872110000 push 00001172
> [000011ba](05) 6872110000 push 00001172
> [000011bf](05) e8aefdffff call 00000f72
> [000011c4](03) 83c408 add esp,+08
> [000011c7](01) 50 push eax
> [000011c8](05) 68a3040000 push 000004a3
> [000011cd](05) e820f3ffff call 000004f2
> [000011d2](03) 83c408 add esp,+08
> [000011d5](02) 33c0 xor eax,eax
> [000011d7](01) 5d pop ebp
> [000011d8](01) c3 ret
> Size in bytes:(0039) [000011d8]
> machine stack stack machine assembly
> address address data code language
> ======== ======== ======== ========= ============> [000011b2][00101f43][00000000] 55 push ebp
> [000011b3][00101f43][00000000] 8bec mov ebp,esp
> [000011b5][00101f3f][00001172] 6872110000 push 00001172
> [000011ba][00101f3b][00001172] 6872110000 push 00001172
> [000011bf][00101f37][000011c4] e8aefdffff call 00000f72
>
> H: Begin Simulation Execution Trace Stored at:211ff7
> Address_of_H:f72
> [00001172][00211fe3][00211fe7] 55 push ebp
> [00001173][00211fe3][00211fe7] 8bec mov ebp,esp
> [00001175][00211fe3][00211fe7] 8b4508 mov eax,[ebp+08]
> [00001178][00211fdf][00001172] 50 push eax
> [00001179][00211fdf][00001172] 8b4d08 mov ecx,[ebp+08]
> [0000117c][00211fdb][00001172] 51 push ecx
> [0000117d][00211fd7][00001182] e8d0ffffff call 00001152
> [00001152][00211fd3][00211fe3] 55 push ebp
> [00001153][00211fd3][00211fe3] 8bec mov ebp,esp
> [00001155][00211fd3][00211fe3] 8b450c mov eax,[ebp+0c]
> [00001158][00211fcf][00001172] 50 push eax
> Calling:_Px()
> Decode_Control_Flow_Instruction([00000008][00211fd3][00001172])
> [00001159][00211fcb][0000115c] ff5508 call dword [ebp+08]
> [00001172][00211fc7][00211fd3] 55 push ebp
> [00001173][00211fc7][00211fd3] 8bec mov ebp,esp
> [00001175][00211fc7][00211fd3] 8b4508 mov eax,[ebp+08]
> [00001178][00211fc3][00001172] 50 push eax
> [00001179][00211fc3][00001172] 8b4d08 mov ecx,[ebp+08]
> [0000117c][00211fbf][00001172] 51 push ecx
> [0000117d][00211fbb][00001182] e8d0ffffff call 00001152
> H: Infinite Recursion Detected Simulation Stopped
>
> [000011c4][00101f43][00000000] 83c408 add esp,+08
> [000011c7][00101f3f][00000000] 50 push eax
> [000011c8][00101f3b][000004a3] 68a3040000 push 000004a3
> [000011cd][00101f3b][000004a3] e820f3ffff call 000004f2
> Input_Halts = 0
> [000011d2][00101f43][00000000] 83c408 add esp,+08
> [000011d5][00101f43][00000000] 33c0 xor eax,eax
> [000011d7][00101f47][00100000] 5d pop ebp
> [000011d8][00101f4b][00000000] c3 ret
> Number of Instructions Executed(2202) == 33 Pages
> >> H sees this and rejects
> >> _Infinite_Loop as non-halting.
> >> --

On 7/1/2022 9:48 AM, Dennis Bush wrote:
> On Friday, July 1, 2022 at 10:22:48 AM UTC-4, olcott wrote:
>> On 7/1/2022 8:50 AM, Dennis Bush wrote:
>>> On Friday, July 1, 2022 at 9:38:06 AM UTC-4, olcott wrote:
>>>> On 7/1/2022 8:18 AM, Dennis Bush wrote:
>>>>> On Friday, July 1, 2022 at 8:55:01 AM UTC-4, olcott wrote:
>>>>>> On 6/30/2022 6:17 PM, Dennis Bush wrote:
>>>>>>> On Thursday, June 30, 2022 at 7:11:01 PM UTC-4, olcott wrote:
>>>>>>>> On 6/30/2022 6:05 PM, Dennis Bush wrote:
>>>>>>>>> On Thursday, June 30, 2022 at 6:57:12 PM UTC-4, olcott wrote:
>>>>>>>>>> On 6/30/2022 5:26 PM, Dennis Bush wrote:
>>>>>>>>>>> On Thursday, June 30, 2022 at 6:23:56 PM UTC-4, olcott wrote:
>>>>>>>>>>>> On 6/30/2022 5:09 PM, Dennis Bush wrote:
>>>
>>>>>>>>>>>> Perhaps you are simply not bright enough to understand that aborted or
>>>>>>>>>>>> not the emulated input never reaches its "ret" instruction.
>>>>>>>>>>>
>>>>>>>>>>> Then you believe that Ha3(N,5)==0 is correct because the emulated input never reaches its "ret" instruction, correct?
>>>>>>>>>>>
>>>>>>>>>>> If not, then explain in detail why it is wrong. Failure to do so will be taken as you asserting that this is correct.
>>>>>>>>>> The problem is not that you are not bright enough the problem is that
>>>>>>>>>> you are a liar that continues to try and get away with the strawman
>>>>>>>>>> deception.
>>>>>>>>>
>>>>>>>>> You said "aborted or not the emulated input never reaches its "ret" instruction". There is no "not" since the fixed algorithm of Ha aborts, so you're saying that because Ha aborts that causes the "ret" instruction to not be reached which is your criteria for returning 0.
>>>>>>>> *This is necessarily true thus impossibly false*
>>>>>>>> Every simulating halt decider that correctly simulates its input until
>>>>>>>> it correctly determines that this simulated input would never reach its
>>>>>>>> final state, correctly rejects this input as non-halting.
>>>>>>>
>>>>>>> So now you're back to "this" simulated input, which means aborting and reporting non-halting is necessarily correct.
>>>>>>>
>>>>>>> Which means you've just affirmed that you agree that Ha3(N,5)==0 is correct.
>>>>>> A dog is an animal is correct thus anyone that disagrees is necessarily
>>>>>> incorrect.
>>>>>> *This is necessarily true thus impossibly false*
>>>>>> Every simulating halt decider that correctly simulates its input until
>>>>>> it correctly determines that this simulated input would never reach its
>>>>>> final state,
>>>>>
>>>>> In other words, for Ha(Pa,Pa) the fixed algorithm of Ha determines if it is able to simulate its input to a final state. It cannot, so you assert that Ha(Pa,Pa)==0 is correct.
>>>> It is not that Ha(Pa,Pa) does not have the ability to simulate its input
>>>> until its input reaches a final state it is the fact that P is calling H
>>>> in infinite recursion that prevents P from ever reaching its final
>>>> state. H sees this and rejects P as non-halting.
>>>
>>> Pa is not calling Ha in infinite recursion. Since Ha is a pure function of its inputs (or at least it should be), Ha(Pa,Pa) will *always* return 0 in all contexts.
>>
>> *This is necessarily true thus impossibly false*
>> Every simulating halt decider that correctly simulates its input until
>> it correctly determines that this simulated input would never reach its
>> final state, correctly rejects this input as non-halting.
>
> So you're just repeating your original point instead of stating why I'm wrong, which means you have no rebuttal.
>
>
>> People that disagree with verified facts are either stupid or liars and
>> you are not stupid.
>>> So a correct simulation of Pa will correctly simulate the call to Ha which aborts *its* internal simulation, breaking the cycle, and will return 0, which causes the simulated Pa to halt.
>>>
>>> This proves that Ha(Pa,Pa)==0 is wrong.
>>>
>>>>
>>>> _Infinite_Loop()
>>>> [00001102](01) 55 push ebp
>>>> [00001103](02) 8bec mov ebp,esp
>>>> [00001105](02) ebfe jmp 00001105
>>>> [00001107](01) 5d pop ebp
>>>> [00001108](01) c3 ret
>>>> Size in bytes:(0007) [00001108]
>>>>
>>>> It is not that H0(_Infinite_Loop) does not have the ability to simulate
>>>> its input until its input reaches a final state it is the fact that
>>>> _Infinite_Loop species an infinite loop that prevents _Infinite_Loop
>>>> from ever reaching its final state.
>>>
>>> Which can be seen in an actual complete simulation, i.e. UTM(_Infinite_Loop), which dictates that returning 0 is correct.
>>>
>> int Simulate(u32 P, u32 I)
>> {
>> ((int(*)(int))P)(I);
>> return 1;
>> }
>>
>> void Px(u32 x)
>> {
>> if (Simulate(x, x))
>> HERE: goto HERE;
>> return;
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", H((u32)Px, (u32)Px));
>> }
>>
>> _Simulate()
>> [00001152](01) 55 push ebp
>> [00001153](02) 8bec mov ebp,esp
>> [00001155](03) 8b450c mov eax,[ebp+0c]
>> [00001158](01) 50 push eax
>> [00001159](03) ff5508 call dword [ebp+08]
>> [0000115c](03) 83c404 add esp,+04
>> [0000115f](05) b801000000 mov eax,00000001
>> [00001164](01) 5d pop ebp
>> [00001165](01) c3 ret
>> Size in bytes:(0020) [00001165]
>>
>> _Px()
>> [00001172](01) 55 push ebp
>> [00001173](02) 8bec mov ebp,esp
>> [00001175](03) 8b4508 mov eax,[ebp+08]
>> [00001178](01) 50 push eax
>> [00001179](03) 8b4d08 mov ecx,[ebp+08]
>> [0000117c](01) 51 push ecx
>> [0000117d](05) e8d0ffffff call 00001152
>> [00001182](03) 83c408 add esp,+08
>> [00001185](02) 85c0 test eax,eax
>> [00001187](02) 7402 jz 0000118b
>> [00001189](02) ebfe jmp 00001189
>> [0000118b](01) 5d pop ebp
>> [0000118c](01) c3 ret
>> Size in bytes:(0027) [0000118c]
>>
>> _main()
>> [000011b2](01) 55 push ebp
>> [000011b3](02) 8bec mov ebp,esp
>> [000011b5](05) 6872110000 push 00001172
>> [000011ba](05) 6872110000 push 00001172
>> [000011bf](05) e8aefdffff call 00000f72
>> [000011c4](03) 83c408 add esp,+08
>> [000011c7](01) 50 push eax
>> [000011c8](05) 68a3040000 push 000004a3
>> [000011cd](05) e820f3ffff call 000004f2
>> [000011d2](03) 83c408 add esp,+08
>> [000011d5](02) 33c0 xor eax,eax
>> [000011d7](01) 5d pop ebp
>> [000011d8](01) c3 ret
>> Size in bytes:(0039) [000011d8]
>> machine stack stack machine assembly
>> address address data code language
>> ======== ======== ======== ========= =============
>> [000011b2][00101f43][00000000] 55 push ebp
>> [000011b3][00101f43][00000000] 8bec mov ebp,esp
>> [000011b5][00101f3f][00001172] 6872110000 push 00001172
>> [000011ba][00101f3b][00001172] 6872110000 push 00001172
>> [000011bf][00101f37][000011c4] e8aefdffff call 00000f72
>>
>> H: Begin Simulation Execution Trace Stored at:211ff7
>> Address_of_H:f72
>> [00001172][00211fe3][00211fe7] 55 push ebp
>> [00001173][00211fe3][00211fe7] 8bec mov ebp,esp
>> [00001175][00211fe3][00211fe7] 8b4508 mov eax,[ebp+08]
>> [00001178][00211fdf][00001172] 50 push eax
>> [00001179][00211fdf][00001172] 8b4d08 mov ecx,[ebp+08]
>> [0000117c][00211fdb][00001172] 51 push ecx
>> [0000117d][00211fd7][00001182] e8d0ffffff call 00001152
>> [00001152][00211fd3][00211fe3] 55 push ebp
>> [00001153][00211fd3][00211fe3] 8bec mov ebp,esp
>> [00001155][00211fd3][00211fe3] 8b450c mov eax,[ebp+0c]
>> [00001158][00211fcf][00001172] 50 push eax
>> Calling:_Px()
>> Decode_Control_Flow_Instruction([00000008][00211fd3][00001172])
>> [00001159][00211fcb][0000115c] ff5508 call dword [ebp+08]
>> [00001172][00211fc7][00211fd3] 55 push ebp
>> [00001173][00211fc7][00211fd3] 8bec mov ebp,esp
>> [00001175][00211fc7][00211fd3] 8b4508 mov eax,[ebp+08]
>> [00001178][00211fc3][00001172] 50 push eax
>> [00001179][00211fc3][00001172] 8b4d08 mov ecx,[ebp+08]
>> [0000117c][00211fbf][00001172] 51 push ecx
>> [0000117d][00211fbb][00001182] e8d0ffffff call 00001152
>> H: Infinite Recursion Detected Simulation Stopped
>>
>> [000011c4][00101f43][00000000] 83c408 add esp,+08
>> [000011c7][00101f3f][00000000] 50 push eax
>> [000011c8][00101f3b][000004a3] 68a3040000 push 000004a3
>> [000011cd][00101f3b][000004a3] e820f3ffff call 000004f2
>> Input_Halts = 0
>> [000011d2][00101f43][00000000] 83c408 add esp,+08
>> [000011d5][00101f43][00000000] 33c0 xor eax,eax
>> [000011d7][00101f47][00100000] 5d pop ebp
>> [000011d8][00101f4b][00000000] c3 ret
>> Number of Instructions Executed(2202) == 33 Pages
>>>> H sees this and rejects
>>>> _Infinite_Loop as non-halting.
>>>> --
>
> This is not Ha(Pa,Pa). Pa calls Ha which has abort logic. Simulate is the same as what was called Hn. So Px is calling Hn, which means that Px is Pn.
>
> So the call in main is actually Ha(Pn,Pn). Pn(Pn) does not halt, nor does UTM(Pn,Pn), so Ha(Pn,Pn)==0 is correct. But's that's not the case we care about. We care about Ha(Pa,Pa). And since Pa(Pa) halts as does UTM(Pa,Pa), Ha(Pa,Pa)==0 is incorrect.
>
>

On 2022-07-01 12:41:14 +0000, olcott said:

> On 7/1/2022 3:55 AM, Mikko wrote:
>> On 2022-06-30 18:30:10 +0000, olcott said:
>>
>>> On 6/30/2022 1:22 PM, Mikko wrote:
>>>> On 2022-06-29 13:00:16 +0000, olcott said:
>>>>
>>>>> IT IS THIS SIMPLE PRINCIPLE THAT REFUTES THE HALTING PROBLEM PROOFS:
>>>>> Every simulating halt decider correctly simulates its input until it
>>>>> correctly determines that this simulated input would never reach its
>>>>> final state.
>>>>
>>>> That does not refute any halting problem proof. Instead, you should prove:
>>>> Some simulating halt decider correctly simulates its input until it
>>>> correctly determines that this simulated input would never reach its
>>>> final state.
>>>>
>>>> Mikko
>>>
>>> I do not see any material difference between the two.
>>
>> For proofs the logical difference between "every" and "some" is more
>> important. In more formal logic ∀ and ∃ are used and they are very
>> different. A common vernacular term for ∀ is "every" or "for every"
>> but "all" or "for all" is also used and sometimes "each" or "for each".
>> For ∃ the vernacular term "some" is often used, or "there is" if one
>> wants to use a verb.
>>
>
> I mean every:

As you said. But that does not refute what you claim to refute.
For that purpose you need "some".

Mikko

On 7/1/2022 10:07 AM, Mikko wrote:
> On 2022-07-01 12:41:14 +0000, olcott said:
>
>> On 7/1/2022 3:55 AM, Mikko wrote:
>>> On 2022-06-30 18:30:10 +0000, olcott said:
>>>
>>>> On 6/30/2022 1:22 PM, Mikko wrote:
>>>>> On 2022-06-29 13:00:16 +0000, olcott said:
>>>>>
>>>>>> IT IS THIS SIMPLE PRINCIPLE THAT REFUTES THE HALTING PROBLEM PROOFS:
>>>>>> Every simulating halt decider correctly simulates its input until
>>>>>> it correctly determines that this simulated input would never
>>>>>> reach its final state.
>>>>>
>>>>> That does not refute any halting problem proof. Instead, you should
>>>>> prove:
>>>>> Some simulating halt decider correctly simulates its input until it
>>>>> correctly determines that this simulated input would never reach
>>>>> its final state.
>>>>>
>>>>> Mikko
>>>>
>>>> I do not see any material difference between the two.
>>>
>>> For proofs the logical difference between "every" and "some" is more
>>> important. In more formal logic ∀ and ∃ are used and they are very
>>> different. A common vernacular term for ∀ is "every" or "for every"
>>> but "all" or "for all" is also used and sometimes "each" or "for each".
>>> For ∃ the vernacular term "some" is often used, or "there is" if one
>>> wants to use a verb.
>>>
>>
>> I mean every:
>
> As you said. But that does not refute what you claim to refute.
> For that purpose you need "some".
>
> Mikko
>

In other words you are saying that a halt decider cannot possisbly be
correct unless it is wrong some of the time, I vehemently disagree.

--
Copyright 2022 Pete Olcott

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

On Friday, July 1, 2022 at 11:05:19 AM UTC-4, olcott wrote:
> On 7/1/2022 9:48 AM, Dennis Bush wrote:
> > On Friday, July 1, 2022 at 10:22:48 AM UTC-4, olcott wrote:
> >> On 7/1/2022 8:50 AM, Dennis Bush wrote:
> >>> On Friday, July 1, 2022 at 9:38:06 AM UTC-4, olcott wrote:
> >>>> On 7/1/2022 8:18 AM, Dennis Bush wrote:
> >>>>> On Friday, July 1, 2022 at 8:55:01 AM UTC-4, olcott wrote:
> >>>>>> On 6/30/2022 6:17 PM, Dennis Bush wrote:
> >>>>>>> On Thursday, June 30, 2022 at 7:11:01 PM UTC-4, olcott wrote:
> >>>>>>>> On 6/30/2022 6:05 PM, Dennis Bush wrote:
> >>>>>>>>> On Thursday, June 30, 2022 at 6:57:12 PM UTC-4, olcott wrote:
> >>>>>>>>>> On 6/30/2022 5:26 PM, Dennis Bush wrote:
> >>>>>>>>>>> On Thursday, June 30, 2022 at 6:23:56 PM UTC-4, olcott wrote:
> >>>>>>>>>>>> On 6/30/2022 5:09 PM, Dennis Bush wrote:
> >>>
> >>>>>>>>>>>> Perhaps you are simply not bright enough to understand that aborted or
> >>>>>>>>>>>> not the emulated input never reaches its "ret" instruction.
> >>>>>>>>>>>
> >>>>>>>>>>> Then you believe that Ha3(N,5)==0 is correct because the emulated input never reaches its "ret" instruction, correct?
> >>>>>>>>>>>
> >>>>>>>>>>> If not, then explain in detail why it is wrong. Failure to do so will be taken as you asserting that this is correct.
> >>>>>>>>>> The problem is not that you are not bright enough the problem is that
> >>>>>>>>>> you are a liar that continues to try and get away with the strawman
> >>>>>>>>>> deception.
> >>>>>>>>>
> >>>>>>>>> You said "aborted or not the emulated input never reaches its "ret" instruction". There is no "not" since the fixed algorithm of Ha aborts, so you're saying that because Ha aborts that causes the "ret" instruction to not be reached which is your criteria for returning 0.
> >>>>>>>> *This is necessarily true thus impossibly false*
> >>>>>>>> Every simulating halt decider that correctly simulates its input until
> >>>>>>>> it correctly determines that this simulated input would never reach its
> >>>>>>>> final state, correctly rejects this input as non-halting.
> >>>>>>>
> >>>>>>> So now you're back to "this" simulated input, which means aborting and reporting non-halting is necessarily correct.
> >>>>>>>
> >>>>>>> Which means you've just affirmed that you agree that Ha3(N,5)==0 is correct.
> >>>>>> A dog is an animal is correct thus anyone that disagrees is necessarily
> >>>>>> incorrect.
> >>>>>> *This is necessarily true thus impossibly false*
> >>>>>> Every simulating halt decider that correctly simulates its input until
> >>>>>> it correctly determines that this simulated input would never reach its
> >>>>>> final state,
> >>>>>
> >>>>> In other words, for Ha(Pa,Pa) the fixed algorithm of Ha determines if it is able to simulate its input to a final state. It cannot, so you assert that Ha(Pa,Pa)==0 is correct.
> >>>> It is not that Ha(Pa,Pa) does not have the ability to simulate its input
> >>>> until its input reaches a final state it is the fact that P is calling H
> >>>> in infinite recursion that prevents P from ever reaching its final
> >>>> state. H sees this and rejects P as non-halting.
> >>>
> >>> Pa is not calling Ha in infinite recursion. Since Ha is a pure function of its inputs (or at least it should be), Ha(Pa,Pa) will *always* return 0 in all contexts.
> >>
> >> *This is necessarily true thus impossibly false*
> >> Every simulating halt decider that correctly simulates its input until
> >> it correctly determines that this simulated input would never reach its
> >> final state, correctly rejects this input as non-halting.
> >
> > So you're just repeating your original point instead of stating why I'm wrong, which means you have no rebuttal.
> >
> >
> >> People that disagree with verified facts are either stupid or liars and
> >> you are not stupid.
> >>> So a correct simulation of Pa will correctly simulate the call to Ha which aborts *its* internal simulation, breaking the cycle, and will return 0, which causes the simulated Pa to halt.
> >>>
> >>> This proves that Ha(Pa,Pa)==0 is wrong.
> >>>
> >>>>
> >>>> _Infinite_Loop()
> >>>> [00001102](01) 55 push ebp
> >>>> [00001103](02) 8bec mov ebp,esp
> >>>> [00001105](02) ebfe jmp 00001105
> >>>> [00001107](01) 5d pop ebp
> >>>> [00001108](01) c3 ret
> >>>> Size in bytes:(0007) [00001108]
> >>>>
> >>>> It is not that H0(_Infinite_Loop) does not have the ability to simulate
> >>>> its input until its input reaches a final state it is the fact that
> >>>> _Infinite_Loop species an infinite loop that prevents _Infinite_Loop
> >>>> from ever reaching its final state.
> >>>
> >>> Which can be seen in an actual complete simulation, i.e. UTM(_Infinite_Loop), which dictates that returning 0 is correct.
> >>>
> >> int Simulate(u32 P, u32 I)
> >> {
> >> ((int(*)(int))P)(I);
> >> return 1;
> >> }
> >>
> >> void Px(u32 x)
> >> {
> >> if (Simulate(x, x))
> >> HERE: goto HERE;
> >> return;
> >> }
> >>
> >> int main()
> >> {
> >> Output("Input_Halts = ", H((u32)Px, (u32)Px));
> >> }
> >>
> >> _Simulate()
> >> [00001152](01) 55 push ebp
> >> [00001153](02) 8bec mov ebp,esp
> >> [00001155](03) 8b450c mov eax,[ebp+0c]
> >> [00001158](01) 50 push eax
> >> [00001159](03) ff5508 call dword [ebp+08]
> >> [0000115c](03) 83c404 add esp,+04
> >> [0000115f](05) b801000000 mov eax,00000001
> >> [00001164](01) 5d pop ebp
> >> [00001165](01) c3 ret
> >> Size in bytes:(0020) [00001165]
> >>
> >> _Px()
> >> [00001172](01) 55 push ebp
> >> [00001173](02) 8bec mov ebp,esp
> >> [00001175](03) 8b4508 mov eax,[ebp+08]
> >> [00001178](01) 50 push eax
> >> [00001179](03) 8b4d08 mov ecx,[ebp+08]
> >> [0000117c](01) 51 push ecx
> >> [0000117d](05) e8d0ffffff call 00001152
> >> [00001182](03) 83c408 add esp,+08
> >> [00001185](02) 85c0 test eax,eax
> >> [00001187](02) 7402 jz 0000118b
> >> [00001189](02) ebfe jmp 00001189
> >> [0000118b](01) 5d pop ebp
> >> [0000118c](01) c3 ret
> >> Size in bytes:(0027) [0000118c]
> >>
> >> _main()
> >> [000011b2](01) 55 push ebp
> >> [000011b3](02) 8bec mov ebp,esp
> >> [000011b5](05) 6872110000 push 00001172
> >> [000011ba](05) 6872110000 push 00001172
> >> [000011bf](05) e8aefdffff call 00000f72
> >> [000011c4](03) 83c408 add esp,+08
> >> [000011c7](01) 50 push eax
> >> [000011c8](05) 68a3040000 push 000004a3
> >> [000011cd](05) e820f3ffff call 000004f2
> >> [000011d2](03) 83c408 add esp,+08
> >> [000011d5](02) 33c0 xor eax,eax
> >> [000011d7](01) 5d pop ebp
> >> [000011d8](01) c3 ret
> >> Size in bytes:(0039) [000011d8]
> >> machine stack stack machine assembly
> >> address address data code language
> >> ======== ======== ======== ========= =============
> >> [000011b2][00101f43][00000000] 55 push ebp
> >> [000011b3][00101f43][00000000] 8bec mov ebp,esp
> >> [000011b5][00101f3f][00001172] 6872110000 push 00001172
> >> [000011ba][00101f3b][00001172] 6872110000 push 00001172
> >> [000011bf][00101f37][000011c4] e8aefdffff call 00000f72
> >>
> >> H: Begin Simulation Execution Trace Stored at:211ff7
> >> Address_of_H:f72
> >> [00001172][00211fe3][00211fe7] 55 push ebp
> >> [00001173][00211fe3][00211fe7] 8bec mov ebp,esp
> >> [00001175][00211fe3][00211fe7] 8b4508 mov eax,[ebp+08]
> >> [00001178][00211fdf][00001172] 50 push eax
> >> [00001179][00211fdf][00001172] 8b4d08 mov ecx,[ebp+08]
> >> [0000117c][00211fdb][00001172] 51 push ecx
> >> [0000117d][00211fd7][00001182] e8d0ffffff call 00001152
> >> [00001152][00211fd3][00211fe3] 55 push ebp
> >> [00001153][00211fd3][00211fe3] 8bec mov ebp,esp
> >> [00001155][00211fd3][00211fe3] 8b450c mov eax,[ebp+0c]
> >> [00001158][00211fcf][00001172] 50 push eax
> >> Calling:_Px()
> >> Decode_Control_Flow_Instruction([00000008][00211fd3][00001172])
> >> [00001159][00211fcb][0000115c] ff5508 call dword [ebp+08]
> >> [00001172][00211fc7][00211fd3] 55 push ebp
> >> [00001173][00211fc7][00211fd3] 8bec mov ebp,esp
> >> [00001175][00211fc7][00211fd3] 8b4508 mov eax,[ebp+08]
> >> [00001178][00211fc3][00001172] 50 push eax
> >> [00001179][00211fc3][00001172] 8b4d08 mov ecx,[ebp+08]
> >> [0000117c][00211fbf][00001172] 51 push ecx
> >> [0000117d][00211fbb][00001182] e8d0ffffff call 00001152
> >> H: Infinite Recursion Detected Simulation Stopped
> >>
> >> [000011c4][00101f43][00000000] 83c408 add esp,+08
> >> [000011c7][00101f3f][00000000] 50 push eax
> >> [000011c8][00101f3b][000004a3] 68a3040000 push 000004a3
> >> [000011cd][00101f3b][000004a3] e820f3ffff call 000004f2
> >> Input_Halts = 0
> >> [000011d2][00101f43][00000000] 83c408 add esp,+08
> >> [000011d5][00101f43][00000000] 33c0 xor eax,eax
> >> [000011d7][00101f47][00100000] 5d pop ebp
> >> [000011d8][00101f4b][00000000] c3 ret
> >> Number of Instructions Executed(2202) == 33 Pages
> >>>> H sees this and rejects
> >>>> _Infinite_Loop as non-halting.
> >>>> --
> >
> > This is not Ha(Pa,Pa). Pa calls Ha which has abort logic. Simulate is the same as what was called Hn. So Px is calling Hn, which means that Px is Pn.
> >
> > So the call in main is actually Ha(Pn,Pn). Pn(Pn) does not halt, nor does UTM(Pn,Pn), so Ha(Pn,Pn)==0 is correct. But's that's not the case we care about. We care about Ha(Pa,Pa). And since Pa(Pa) halts as does UTM(Pa,Pa), Ha(Pa,Pa)==0 is incorrect.
> >
> >
> Ha(Pa,Pa) correctly predicts that its complete and correct x86 emulation
> of its input would never reach the "ret" instruction of this input.
> <snipped useless repeat of original point>

Python wrote:

> Demented uncompetent kook Peter Olcott wrote:
>> [pathetic evading idiocies]
>
> 0x8054 <_start> mov r0, pc 0x8058 <_start+4> mov r0, #2 0x805c
> <_start+8> add r1, r0, r0 0x8060 <_start+12> bkpt 0x0000

nazi cocaine zelenske keeps the world hostage and starving.

As West blames Moscow for 'food crisis', ships sail from Mariupol with
Moscow's help while Ukraine holds vessels in its ports
https://www.rt.com/russia/558011-foreign-ships-leave-mariupol/

More blatant disinformation from our US colleagues. They perfectly know
that the Ukrainian ports are mined by Kiev and our offers of humanitarian
sea passages were repeatedly rejected. And don’t trigger famine in
#Ukraine by depriving it of grain-don’t tell us we didn’t warn you!
https://t.co/Y9PqG9hoJZ

On 7/1/22 8:54 AM, olcott wrote:
> On 6/30/2022 6:17 PM, Dennis Bush wrote:
>> On Thursday, June 30, 2022 at 7:11:01 PM UTC-4, olcott wrote:
>>> On 6/30/2022 6:05 PM, Dennis Bush wrote:
>>>> On Thursday, June 30, 2022 at 6:57:12 PM UTC-4, olcott wrote:
>>>>> On 6/30/2022 5:26 PM, Dennis Bush wrote:
>>>>>> On Thursday, June 30, 2022 at 6:23:56 PM UTC-4, olcott wrote:
>>>>>>> On 6/30/2022 5:09 PM, Dennis Bush wrote:
>>>>>>>> On Thursday, June 30, 2022 at 5:52:37 PM UTC-4, olcott wrote:
>>>>>>>>> On 6/30/2022 3:50 PM, Dennis Bush wrote:
>>>>>>>>>> On Thursday, June 30, 2022 at 4:22:57 PM UTC-4, olcott wrote:
>>>>>>>>>>> On 6/30/2022 11:55 AM, Dennis Bush wrote:
>>>>>>>>>>>> On Thursday, June 30, 2022 at 12:43:17 PM UTC-4, olcott wrote:
>>>>>>>>>>>>> On 6/30/2022 11:34 AM, Dennis Bush wrote:
>>>>>>>>>>>>>> On Thursday, June 30, 2022 at 12:15:58 PM UTC-4, olcott
>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>> On 6/30/2022 10:40 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>> On Thursday, June 30, 2022 at 11:36:43 AM UTC-4, olcott
>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>> On 6/30/2022 7:12 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>> On Thursday, June 30, 2022 at 12:59:38 AM UTC-4,
>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>> On 6/29/2022 11:51 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>> On Thursday, June 30, 2022 at 12:42:59 AM UTC-4,
>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 6/29/2022 9:02 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>> On Wednesday, June 29, 2022 at 9:44:39 AM UTC-4,
>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 6/28/2022 8:44 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Every simulating halt decider correctly simulates
>>>>>>>>>>>>>>>>>>>>>>> its input until it
>>>>>>>>>>>>>>>>>>>>>>> correctly determines that this simulated input
>>>>>>>>>>>>>>>>>>>>>>> would never reach its
>>>>>>>>>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>>>>>>>>>>> I don't know why you keep making the ridiculous
>>>>>>>>>>>>>>>>>>>>>>> assertion that a
>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider cannot possibly
>>>>>>>>>>>>>>>>>>>>>>> predict/determine that its
>>>>>>>>>>>>>>>>>>>>>>> complete and correct x86 emulation of its input
>>>>>>>>>>>>>>>>>>>>>>> would never reach the
>>>>>>>>>>>>>>>>>>>>>>> "ret" instruction of this input.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> But Ha doesn't *do* a complete and correct
>>>>>>>>>>>>>>>>>>>>>> emulation of its input as per its fixed algorithm,
>>>>>>>>>>>>>>>>>>>>>> so to say what the complete and correct emulation
>>>>>>>>>>>>>>>>>>>>>> of the input to Ha(Pa,Pa) by Ha is, is simply
>>>>>>>>>>>>>>>>>>>>>> nonsense.
>>>>>>>>>>>>>>>>>>>>> To continue to insist that a simulating halt
>>>>>>>>>>>>>>>>>>>>> decider cannot correctly
>>>>>>>>>>>>>>>>>>>>> predict (in a finite number of steps) that its
>>>>>>>>>>>>>>>>>>>>> complete and correct x86
>>>>>>>>>>>>>>>>>>>>> emulation of its input
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Which does not exist because Ha aborts and therefore
>>>>>>>>>>>>>>>>>>>> does not do a complete and correct x86 emulation.
>>>>>>>>>>>>>>>>>>> We are taking that what you are saying means that you
>>>>>>>>>>>>>>>>>>> believe it is
>>>>>>>>>>>>>>>>>>> impossible for H to correctly determine that
>>>>>>>>>>>>>>>>>>> Infinite_Loop() never halts.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> No, you're saying that the correctness criteria for
>>>>>>>>>>>>>>>>>> Ha(Pa,Pa) is a complete and correct emulation of the
>>>>>>>>>>>>>>>>>> input *by Ha*. And because Ha has a fixed algorithm
>>>>>>>>>>>>>>>>>> that aborts, Ha does not do a complete and correct
>>>>>>>>>>>>>>>>>> emulation of the input.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> And because Ha does not do a complete and correct
>>>>>>>>>>>>>>>>>> emulation of the input, what I'm saying is that your
>>>>>>>>>>>>>>>>>> correctness criteria simply doesn't exist.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> That is a Jackass (deceptive head games) thing to say
>>>>>>>>>>>>>>>>> when you already
>>>>>>>>>>>>>>>>> know that H merely needs to correctly predict what the
>>>>>>>>>>>>>>>>> complete and
>>>>>>>>>>>>>>>>> correct x86 emulation of its input would do and it need
>>>>>>>>>>>>>>>>> not actually to
>>>>>>>>>>>>>>>>> a complete emulation to do this. EXAMPLE BELOW
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *The* complete and correct emulation of the input to
>>>>>>>>>>>>>>>> Ha(Pa,Pa) is performed by UTM(Pa,Pa) which halts,
>>>>>>>>>>>>>>>> proving that Ha(Pa,Pa)==0 is wrong.
>>>>>>>>>>>>>>> The part that you keep erasing proves that you are a liar.
>>>>>>>>>>>>>>> You keep erasing it because you know that it proves you
>>>>>>>>>>>>>>> are a liar.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Infinite_Loop was previously shown to be irrelevant.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Changing the subject to a completely different
>>>>>>>>>>>>>>> computation UTM(Pa,Pa)
>>>>>>>>>>>>>>> than the actual computation Ha(Pa,Pa) is the strawman
>>>>>>>>>>>>>>> deception.
>>>>>>>>>>>>>>> straw man
>>>>>>>>>>>>>>> An intentionally misrepresented proposition that is set
>>>>>>>>>>>>>>> up because it is
>>>>>>>>>>>>>>> easier to defeat than an opponent's real argument.
>>>>>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I'm not changing the subject. I'm just going by what
>>>>>>>>>>>>>> you're saying.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> THIS IS NECESSARILY TRUE THUS IMPOSSIBLY FALSE
>>>>>>>>>>>>>>> Every simulating halt decider correctly simulates its
>>>>>>>>>>>>>>> input until it
>>>>>>>>>>>>>>> correctly determines that this simulated input would
>>>>>>>>>>>>>>> never reach its
>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You keep changing this part. Sometimes you say "the"
>>>>>>>>>>>>>> simulated input, sometimes "its" simulated input,
>>>>>>>>>>>>>> sometimes "this" simulated input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *The* complete and correct simulation of the input to
>>>>>>>>>>>>>> Ha(Pa,Pa) is by definition performed by UTM(Pa,Pa).
>>>>>>>>>>>>> That is a lie and you know it.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The actual behavior of the actual input to H(P,P) is
>>>>>>>>>>>>> conclusively proven
>>>>>>>>>>>>> to diverge from the actual behavior of the actual input to
>>>>>>>>>>>>> H1(P,P) on
>>>>>>>>>>>>> the basis of the semantics of the x86 language.
>>>>>>>>>>>>
>>>>>>>>>>>> Then what is the first x86 instruction where the behavior of
>>>>>>>>>>>> Ha(Pa,Pa) and UTM(Pa,Pa) differ?
>>>>>>>>>>>>
>>>>>>>>>>> [0000164a][00212749][0021274d] 83c408 add esp,+08
>>>>>>>>>>
>>>>>>>>>> FALSE
>>>>>>>>>>
>>>>>>>>>> The simulation performed by Ha is aborted before that
>>>>>>>>>> instruction can be reached.
>>>>>>>>> Aborted or not the above instruction is the first instruction that
>>>>>>>>> differs.
>>>>>>>>
>>>>>>>> That instruction doesn't differ between the two simulations
>>>>>>>> because Ha stopped before it got there.
>>>>>>> Perhaps you are simply not bright enough to understand that
>>>>>>> aborted or
>>>>>>> not the emulated input never reaches its "ret" instruction.
>>>>>>
>>>>>> Then you believe that Ha3(N,5)==0 is correct because the emulated
>>>>>> input never reaches its "ret" instruction, correct?
>>>>>>
>>>>>> If not, then explain in detail why it is wrong. Failure to do so
>>>>>> will be taken as you asserting that this is correct.
>>>>> The problem is not that you are not bright enough the problem is that
>>>>> you are a liar that continues to try and get away with the strawman
>>>>> deception.
>>>>
>>>> You said "aborted or not the emulated input never reaches its "ret"
>>>> instruction". There is no "not" since the fixed algorithm of Ha
>>>> aborts, so you're saying that because Ha aborts that causes the
>>>> "ret" instruction to not be reached which is your criteria for
>>>> returning 0.
>>> *This is necessarily true thus impossibly false*
>>> Every simulating halt decider that correctly simulates its input until
>>> it correctly determines that this simulated input would never reach its
>>> final state, correctly rejects this input as non-halting.
>>
>> So now you're back to "this" simulated input, which means aborting and
>> reporting non-halting is necessarily correct.
>>
>> Which means you've just affirmed that you agree that Ha3(N,5)==0 is
>> correct.
>
> A dog is an animal is correct thus anyone that disagrees is necessarily
> incorrect.
>
> *This is necessarily true thus impossibly false*
> Every simulating halt decider that correctly simulates its input until
> it correctly determines that this simulated input would never reach its
> final state, correctly rejects this input as non-halting.
>
> That you disagree with necessarily true statements makes you either
> lacking sufficient technical skills or a liar.
>

On 7/1/22 11:05 AM, olcott wrote:
> On 7/1/2022 9:48 AM, Dennis Bush wrote:
>> On Friday, July 1, 2022 at 10:22:48 AM UTC-4, olcott wrote:
>>> On 7/1/2022 8:50 AM, Dennis Bush wrote:
>>>> On Friday, July 1, 2022 at 9:38:06 AM UTC-4, olcott wrote:
>>>>> On 7/1/2022 8:18 AM, Dennis Bush wrote:
>>>>>> On Friday, July 1, 2022 at 8:55:01 AM UTC-4, olcott wrote:
>>>>>>> On 6/30/2022 6:17 PM, Dennis Bush wrote:
>>>>>>>> On Thursday, June 30, 2022 at 7:11:01 PM UTC-4, olcott wrote:
>>>>>>>>> On 6/30/2022 6:05 PM, Dennis Bush wrote:
>>>>>>>>>> On Thursday, June 30, 2022 at 6:57:12 PM UTC-4, olcott wrote:
>>>>>>>>>>> On 6/30/2022 5:26 PM, Dennis Bush wrote:
>>>>>>>>>>>> On Thursday, June 30, 2022 at 6:23:56 PM UTC-4, olcott wrote:
>>>>>>>>>>>>> On 6/30/2022 5:09 PM, Dennis Bush wrote:
>>>>
>>>>>>>>>>>>> Perhaps you are simply not bright enough to understand that
>>>>>>>>>>>>> aborted or
>>>>>>>>>>>>> not the emulated input never reaches its "ret" instruction.
>>>>>>>>>>>>
>>>>>>>>>>>> Then you believe that Ha3(N,5)==0 is correct because the
>>>>>>>>>>>> emulated input never reaches its "ret" instruction, correct?
>>>>>>>>>>>>
>>>>>>>>>>>> If not, then explain in detail why it is wrong. Failure to
>>>>>>>>>>>> do so will be taken as you asserting that this is correct.
>>>>>>>>>>> The problem is not that you are not bright enough the problem
>>>>>>>>>>> is that
>>>>>>>>>>> you are a liar that continues to try and get away with the
>>>>>>>>>>> strawman
>>>>>>>>>>> deception.
>>>>>>>>>>
>>>>>>>>>> You said "aborted or not the emulated input never reaches its
>>>>>>>>>> "ret" instruction". There is no "not" since the fixed
>>>>>>>>>> algorithm of Ha aborts, so you're saying that because Ha
>>>>>>>>>> aborts that causes the "ret" instruction to not be reached
>>>>>>>>>> which is your criteria for returning 0.
>>>>>>>>> *This is necessarily true thus impossibly false*
>>>>>>>>> Every simulating halt decider that correctly simulates its
>>>>>>>>> input until
>>>>>>>>> it correctly determines that this simulated input would never
>>>>>>>>> reach its
>>>>>>>>> final state, correctly rejects this input as non-halting.
>>>>>>>>
>>>>>>>> So now you're back to "this" simulated input, which means
>>>>>>>> aborting and reporting non-halting is necessarily correct.
>>>>>>>>
>>>>>>>> Which means you've just affirmed that you agree that Ha3(N,5)==0
>>>>>>>> is correct.
>>>>>>> A dog is an animal is correct thus anyone that disagrees is
>>>>>>> necessarily
>>>>>>> incorrect.
>>>>>>> *This is necessarily true thus impossibly false*
>>>>>>> Every simulating halt decider that correctly simulates its input
>>>>>>> until
>>>>>>> it correctly determines that this simulated input would never
>>>>>>> reach its
>>>>>>> final state,
>>>>>>
>>>>>> In other words, for Ha(Pa,Pa) the fixed algorithm of Ha determines
>>>>>> if it is able to simulate its input to a final state. It cannot,
>>>>>> so you assert that Ha(Pa,Pa)==0 is correct.
>>>>> It is not that Ha(Pa,Pa) does not have the ability to simulate its
>>>>> input
>>>>> until its input reaches a final state it is the fact that P is
>>>>> calling H
>>>>> in infinite recursion that prevents P from ever reaching its final
>>>>> state. H sees this and rejects P as non-halting.
>>>>
>>>> Pa is not calling Ha in infinite recursion. Since Ha is a pure
>>>> function of its inputs (or at least it should be), Ha(Pa,Pa) will
>>>> *always* return 0 in all contexts.
>>>
>>> *This is necessarily true thus impossibly false*
>>> Every simulating halt decider that correctly simulates its input until
>>> it correctly determines that this simulated input would never reach its
>>> final state, correctly rejects this input as non-halting.
>>
>> So you're just repeating your original point instead of stating why
>> I'm wrong, which means you have no rebuttal.
>>
>>
>>> People that disagree with verified facts are either stupid or liars and
>>> you are not stupid.
>>>> So a correct simulation of Pa will correctly simulate the call to Ha
>>>> which aborts *its* internal simulation, breaking the cycle, and will
>>>> return 0, which causes the simulated Pa to halt.
>>>>
>>>> This proves that Ha(Pa,Pa)==0 is wrong.
>>>>
>>>>>
>>>>> _Infinite_Loop()
>>>>> [00001102](01) 55 push ebp
>>>>> [00001103](02) 8bec mov ebp,esp
>>>>> [00001105](02) ebfe jmp 00001105
>>>>> [00001107](01) 5d pop ebp
>>>>> [00001108](01) c3 ret
>>>>> Size in bytes:(0007) [00001108]
>>>>>
>>>>> It is not that H0(_Infinite_Loop) does not have the ability to
>>>>> simulate
>>>>> its input until its input reaches a final state it is the fact that
>>>>> _Infinite_Loop species an infinite loop that prevents _Infinite_Loop
>>>>> from ever reaching its final state.
>>>>
>>>> Which can be seen in an actual complete simulation, i.e.
>>>> UTM(_Infinite_Loop), which dictates that returning 0 is correct.
>>>>
>>> int Simulate(u32 P, u32 I)
>>> {
>>> ((int(*)(int))P)(I);
>>> return 1;
>>> }
>>>
>>> void Px(u32 x)
>>> {
>>> if (Simulate(x, x))
>>> HERE: goto HERE;
>>> return;
>>> }
>>>
>>> int main()
>>> {
>>> Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>> }
>>>
>>> _Simulate()
>>> [00001152](01) 55 push ebp
>>> [00001153](02) 8bec mov ebp,esp
>>> [00001155](03) 8b450c mov eax,[ebp+0c]
>>> [00001158](01) 50 push eax
>>> [00001159](03) ff5508 call dword [ebp+08]
>>> [0000115c](03) 83c404 add esp,+04
>>> [0000115f](05) b801000000 mov eax,00000001
>>> [00001164](01) 5d pop ebp
>>> [00001165](01) c3 ret
>>> Size in bytes:(0020) [00001165]
>>>
>>> _Px()
>>> [00001172](01) 55 push ebp
>>> [00001173](02) 8bec mov ebp,esp
>>> [00001175](03) 8b4508 mov eax,[ebp+08]
>>> [00001178](01) 50 push eax
>>> [00001179](03) 8b4d08 mov ecx,[ebp+08]
>>> [0000117c](01) 51 push ecx
>>> [0000117d](05) e8d0ffffff call 00001152
>>> [00001182](03) 83c408 add esp,+08
>>> [00001185](02) 85c0 test eax,eax
>>> [00001187](02) 7402 jz 0000118b
>>> [00001189](02) ebfe jmp 00001189
>>> [0000118b](01) 5d pop ebp
>>> [0000118c](01) c3 ret
>>> Size in bytes:(0027) [0000118c]
>>>
>>> _main()
>>> [000011b2](01) 55 push ebp
>>> [000011b3](02) 8bec mov ebp,esp
>>> [000011b5](05) 6872110000 push 00001172
>>> [000011ba](05) 6872110000 push 00001172
>>> [000011bf](05) e8aefdffff call 00000f72
>>> [000011c4](03) 83c408 add esp,+08
>>> [000011c7](01) 50 push eax
>>> [000011c8](05) 68a3040000 push 000004a3
>>> [000011cd](05) e820f3ffff call 000004f2
>>> [000011d2](03) 83c408 add esp,+08
>>> [000011d5](02) 33c0 xor eax,eax
>>> [000011d7](01) 5d pop ebp
>>> [000011d8](01) c3 ret
>>> Size in bytes:(0039) [000011d8]
>>> machine stack stack machine assembly
>>> address address data code language
>>> ======== ======== ======== ========= =============
>>> [000011b2][00101f43][00000000] 55 push ebp
>>> [000011b3][00101f43][00000000] 8bec mov ebp,esp
>>> [000011b5][00101f3f][00001172] 6872110000 push 00001172
>>> [000011ba][00101f3b][00001172] 6872110000 push 00001172
>>> [000011bf][00101f37][000011c4] e8aefdffff call 00000f72
>>>
>>> H: Begin Simulation Execution Trace Stored at:211ff7
>>> Address_of_H:f72
>>> [00001172][00211fe3][00211fe7] 55 push ebp
>>> [00001173][00211fe3][00211fe7] 8bec mov ebp,esp
>>> [00001175][00211fe3][00211fe7] 8b4508 mov eax,[ebp+08]
>>> [00001178][00211fdf][00001172] 50 push eax
>>> [00001179][00211fdf][00001172] 8b4d08 mov ecx,[ebp+08]
>>> [0000117c][00211fdb][00001172] 51 push ecx
>>> [0000117d][00211fd7][00001182] e8d0ffffff call 00001152
>>> [00001152][00211fd3][00211fe3] 55 push ebp
>>> [00001153][00211fd3][00211fe3] 8bec mov ebp,esp
>>> [00001155][00211fd3][00211fe3] 8b450c mov eax,[ebp+0c]
>>> [00001158][00211fcf][00001172] 50 push eax
>>> Calling:_Px()
>>> Decode_Control_Flow_Instruction([00000008][00211fd3][00001172])
>>> [00001159][00211fcb][0000115c] ff5508 call dword [ebp+08]
>>> [00001172][00211fc7][00211fd3] 55 push ebp
>>> [00001173][00211fc7][00211fd3] 8bec mov ebp,esp
>>> [00001175][00211fc7][00211fd3] 8b4508 mov eax,[ebp+08]
>>> [00001178][00211fc3][00001172] 50 push eax
>>> [00001179][00211fc3][00001172] 8b4d08 mov ecx,[ebp+08]
>>> [0000117c][00211fbf][00001172] 51 push ecx
>>> [0000117d][00211fbb][00001182] e8d0ffffff call 00001152
>>> H: Infinite Recursion Detected Simulation Stopped
>>>
>>> [000011c4][00101f43][00000000] 83c408 add esp,+08
>>> [000011c7][00101f3f][00000000] 50 push eax
>>> [000011c8][00101f3b][000004a3] 68a3040000 push 000004a3
>>> [000011cd][00101f3b][000004a3] e820f3ffff call 000004f2
>>> Input_Halts = 0
>>> [000011d2][00101f43][00000000] 83c408 add esp,+08
>>> [000011d5][00101f43][00000000] 33c0 xor eax,eax
>>> [000011d7][00101f47][00100000] 5d pop ebp
>>> [000011d8][00101f4b][00000000] c3 ret
>>> Number of Instructions Executed(2202) == 33 Pages
>>>>> H sees this and rejects
>>>>> _Infinite_Loop as non-halting.
>>>>> --
>>
>> This is not Ha(Pa,Pa).  Pa calls Ha which has abort logic.  Simulate
>> is the same as what was called Hn.  So Px is calling Hn, which means
>> that Px is Pn.
>>
>> So the call in main is actually Ha(Pn,Pn).   Pn(Pn) does not halt, nor
>> does UTM(Pn,Pn), so Ha(Pn,Pn)==0 is correct.  But's that's not the
>> case we care about.  We care about Ha(Pa,Pa).  And since Pa(Pa) halts
>> as does UTM(Pa,Pa), Ha(Pa,Pa)==0 is incorrect.
>>
>>
>
> Ha(Pa,Pa) correctly predicts that its complete and correct x86 emulation
> of its input would never reach the "ret" instruction of this input.
>
> *This is necessarily true thus impossibly false*
> Every simulating halt decider that correctly simulates its input until
> it correctly determines that this simulated input would never reach its
> final state, correctly rejects this input as non-halting.
>