// Simplified Linz Ĥ (Linz:1990:319)
// Strachey(1965) CPL translated to C
void P(u32 x)
{ if (H(x, x))
HERE: goto HERE;
}

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

We can analyze H(P,P) at the very high level of abstraction of its two
possible behaviors relative to its input allows us to concisely prove
that not halting <is> the correct decision for this input. No matter how
H works internally the only thing that counts is the behavior of its
input for the two possible behaviors that H can have.

Since the input to H(P,P) never reaches its final state for the two
possible behaviors that every H can possibly have (abort the input or do
not abort the input) then we can conclude that not halting is the
correct decision for every possible simulating halt decider H.

Halting problem undecidability and infinitely nested simulation
May 2021 PL Olcott

https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

--
Copyright 2021 Pete Olcott

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

olcott <NoOne@NoWhere.com> writes:

Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2

No. H(P,P) == 0 is correct if, and only if, P(P) does not halt. But
(according to you -- we are not allowed to see the full code) P(P)
halts:

|| Here's the key question: do you still assert that H(P,P) == false is
|| the "correct" answer even though P(P) halts?

| Yes that is the correct answer even though P(P) halts.

No waffle can alter the fact that false (or 0 etc.) is the wrong return.

--
Ben.

On 10/31/21 11:45 PM, olcott wrote:
> // Simplified Linz Ĥ (Linz:1990:319)
> // Strachey(1965) CPL translated to C
> void P(u32 x)
> {
>   if (H(x, x))
>     HERE: goto HERE;
> }
>
> int main()
> {
>   Output("Input_Halts = ", H((u32)P, (u32)P));
> }
>
> We can analyze H(P,P) at the very high level of abstraction of its two
> possible behaviors relative to its input allows us to concisely prove
> that not halting <is> the correct decision for this input. No matter how
> H works internally the only thing that counts is the behavior of its
> input for the two possible behaviors that H can have.

Error in Logic. A given H can't have 'two possible behavior', so you
logic isn't about what a given H does, but tells us something about a
family of functions. Note, Each H is analyzing a DIFFERENT P (since P is
defined to be built on the H that it is supposed to confound), so what
one H proves about its P does not tell us anything about the P of another H.

The fact that a given Halt Decider doesn't reach a halting state before
it terminates its simulation for some reason does NOT prove that the
Computation is non-halting, it just shows that the halt decider hasn't
PROVEN that the computation is Halting, or hasn't halted in the X steps
that it has simulated. Since Non-Halting requires that this be true for
ANY finite number, there are many (an infinite) number of possible steps
for the machine to still halt in. Only simulation for an unbounded
number of steps without reaching a halting state directly shows that a
computation is non-halting.

Yes, the H that doesn't ever abort its simulation does prove that ITS P
is non-halting, but it doesn't report that fact in finite time, as it
takes it infinite time to make that determination. From the above, we
also know that this does NOT imply that any other P is also non-halting.

>
> Since the input to H(P,P) never reaches its final state for the two
> possible behaviors that every H can possibly have (abort the input or do
> not abort the input) then we can conclude that not halting is the
> correct decision for every possible simulating halt decider H.

Wrong, using wrong definition.

UTM(P,P) will Halt for all P based on an H which answers Non-Halting for
H(P,P).

THIS is the criteria that the Halt decider is SUPPOSED to use, so H is
WRONG when it says non-halting. Remember, the Halt decider is supposed
to indicate the halting status of the ACTUAL COMPUTATION REPRESENETED by
the input, which is definitionally equivalent to that exact same input
being used as the input to a true UTM (which never aborts its input).

Switching to using the deciders behavior on the input is incorrect as it
suddenly makes a property of the Computation itself (does this
computation halt) dependent on who is deciding. For example, with this
definition, ALL Computations are 'correctly' decided as non-halting by a
simulating halt decider that just immediately halts and declares that
its input is non-halting. This makes your 'alternate' definition a
totally WORTHLESS property.

>
> Halting problem undecidability and infinitely nested simulation
> May 2021 PL Olcott
>
> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>
>
>
>

On Monday, 1 November 2021 at 03:45:47 UTC, olcott wrote:
> // Simplified Linz Ĥ (Linz:1990:319)
> // Strachey(1965) CPL translated to C
> void P(u32 x)
> {
> if (H(x, x))
> HERE: goto HERE;
> }
>
> int main()
> {
> Output("Input_Halts = ", H((u32)P, (u32)P));
> }
>
> We can analyze H(P,P) at the very high level of abstraction of its two
> possible behaviors relative to its input allows us to concisely prove
> that not halting <is> the correct decision for this input. No matter how
> H works internally the only thing that counts is the behavior of its
> input for the two possible behaviors that H can have.
>
> Since the input to H(P,P) never reaches its final state for the two
> possible behaviors that every H can possibly have (abort the input or do
> not abort the input) then we can conclude that not halting is the
> correct decision for every possible simulating halt decider H.
>
I can see where the confusion lies. If H never aborts, it simulates P forever.
If it aborts, then it aborts because it has detected that otherwise P would
simulate forever.

What you are forgetting is that P depends on H. If H aborts, the P would also
abort i.e. terminate. So if H aborts P, it aborts incorrectly, despite the fact
that if it didn't abort, P would run forever.
That seems like a contradiction, but it isn't really, because we are talking
about two Ps, one with an H which never aborts, one with an H that aborts.

Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:

> On Monday, 1 November 2021 at 03:45:47 UTC, olcott wrote:
>> // Simplified Linz Ĥ (Linz:1990:319)
>> // Strachey(1965) CPL translated to C
>> void P(u32 x)
>> {
>> if (H(x, x))
>> HERE: goto HERE;
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", H((u32)P, (u32)P));
>> }
>>
>> We can analyze H(P,P) at the very high level of abstraction of its two
>> possible behaviors relative to its input allows us to concisely prove
>> that not halting <is> the correct decision for this input. No matter how
>> H works internally the only thing that counts is the behavior of its
>> input for the two possible behaviors that H can have.
>>
>> Since the input to H(P,P) never reaches its final state for the two
>> possible behaviors that every H can possibly have (abort the input or do
>> not abort the input) then we can conclude that not halting is the
>> correct decision for every possible simulating halt decider H.
>>
> I can see where the confusion lies. If H never aborts, it simulates P forever.
> If it aborts, then it aborts because it has detected that otherwise P would
> simulate forever.
>
> What you are forgetting is that P depends on H.

What makes you think he's forgetting that? Having (at least) two
different Hs without changing H^ (now called P) has been the ruse for
months and months.

His Halts function was declared correct because of what would happen if
line 15 were commented out. It has always been some variation of the
theme of "the wrong answer is right because of what would happen if H
(but not H^) were not the function it really is".

> If H aborts, the P would also
> abort i.e. terminate. So if H aborts P, it aborts incorrectly, despite the fact
> that if it didn't abort, P would run forever.
> That seems like a contradiction, but it isn't really, because we are talking
> about two Ps, one with an H which never aborts, one with an H that
> aborts.

Do you think the change of name from a dependent one (H^) to one that
hides the dependence (P) is an accident? Might is not be part of the
scheme to find words that make the wrong answer, H(P,P) == false, seem
less wrong despite the fact that P(P) halts?

--
Ben.

On 11/1/2021 7:46 AM, Malcolm McLean wrote:
> On Monday, 1 November 2021 at 03:45:47 UTC, olcott wrote:
>> // Simplified Linz Ĥ (Linz:1990:319)
>> // Strachey(1965) CPL translated to C
>> void P(u32 x)
>> {
>> if (H(x, x))
>> HERE: goto HERE;
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", H((u32)P, (u32)P));
>> }
>>
>> We can analyze H(P,P) at the very high level of abstraction of its two
>> possible behaviors relative to its input allows us to concisely prove
>> that not halting <is> the correct decision for this input. No matter how
>> H works internally the only thing that counts is the behavior of its
>> input for the two possible behaviors that H can have.
>>
>> Since the input to H(P,P) never reaches its final state for the two
>> possible behaviors that every H can possibly have (abort the input or do
>> not abort the input) then we can conclude that not halting is the
>> correct decision for every possible simulating halt decider H.
>>
> I can see where the confusion lies. If H never aborts, it simulates P forever.
> If it aborts, then it aborts because it has detected that otherwise P would
> simulate forever.
>
> What you are forgetting is that P depends on H. If H aborts, the P would also
> abort i.e. terminate. So if H aborts P, it aborts incorrectly, despite the fact
> that if it didn't abort, P would run forever.
> That seems like a contradiction, but it isn't really, because we are talking
> about two Ps, one with an H which never aborts, one with an H that aborts.
>

void Infinite_Loop()
{ HERE: goto HERE;
}

_Infinite_Loop()
[00000ab0](01) 55 push ebp
[00000ab1](02) 8bec mov ebp,esp
[00000ab3](02) ebfe jmp 00000ab3
[00000ab5](01) 5d pop ebp
[00000ab6](01) c3 ret
Size in bytes:(0007) [00000ab6]

If H allows Infinite_Loop() to continue then Infinite_Loop() never
reaches its final state of 0xab6. If H aborts its simulation of
Infinite_Loop() then it stops at 0xab3 and never reaches its final state
of 0xab6. H(P,P) is the same situation:

We are talking about this case shown below which conclusively proves
that every simulating halt decider H must abort its simulation its input
otherwise (just like the infinite loop shown above) its input never halts.

Aborting the input does not count as halting because the input never
reaches its final state no matter what H does. Any input that never
reaches its final state NO MATTER WHAT is an input that never halts.

// Simplified Linz Ĥ (Linz:1990:319)
// Strachey(1965) CPL translated to C
void P(u32 x)
{ if (H(x, x))
HERE: goto HERE;
}

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

_P()
[00000c36](01) 55 push ebp
[00000c37](02) 8bec mov ebp,esp
[00000c39](03) 8b4508 mov eax,[ebp+08] // 2nd Param
[00000c3c](01) 50 push eax
[00000c3d](03) 8b4d08 mov ecx,[ebp+08] // 1st Param
[00000c40](01) 51 push ecx
[00000c41](05) e820fdffff call 00000966 // call H
[00000c46](03) 83c408 add esp,+08
[00000c49](02) 85c0 test eax,eax
[00000c4b](02) 7402 jz 00000c4f
[00000c4d](02) ebfe jmp 00000c4d
[00000c4f](01) 5d pop ebp
[00000c50](01) c3 ret
Size in bytes:(0027) [00000c50]

_main()
[00000c56](01) 55 push ebp
[00000c57](02) 8bec mov ebp,esp
[00000c59](05) 68360c0000 push 00000c36 // push P
[00000c5e](05) 68360c0000 push 00000c36 // push P
[00000c63](05) e8fefcffff call 00000966 // call H(P,P)
[00000c68](03) 83c408 add esp,+08
[00000c6b](01) 50 push eax
[00000c6c](05) 6857030000 push 00000357
[00000c71](05) e810f7ffff call 00000386
[00000c76](03) 83c408 add esp,+08
[00000c79](02) 33c0 xor eax,eax
[00000c7b](01) 5d pop ebp
[00000c7c](01) c3 ret
Size in bytes:(0039) [00000c7c]

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00000c56][0010172a][00000000] 55 push ebp
[00000c57][0010172a][00000000] 8bec mov ebp,esp
[00000c59][00101726][00000c36] 68360c0000 push 00000c36 // push P
[00000c5e][00101722][00000c36] 68360c0000 push 00000c36 // push P
[00000c63][0010171e][00000c68] e8fefcffff call 00000966 // call H(P,P)

Begin Local Halt Decider Simulation at Machine Address:c36
[00000c36][002117ca][002117ce] 55 push ebp
[00000c37][002117ca][002117ce] 8bec mov ebp,esp
[00000c39][002117ca][002117ce] 8b4508 mov eax,[ebp+08]
[00000c3c][002117c6][00000c36] 50 push eax // push P
[00000c3d][002117c6][00000c36] 8b4d08 mov ecx,[ebp+08]
[00000c40][002117c2][00000c36] 51 push ecx // push P
[00000c41][002117be][00000c46] e820fdffff call 00000966 // call H(P,P)

[00000c36][0025c1f2][0025c1f6] 55 push ebp
[00000c37][0025c1f2][0025c1f6] 8bec mov ebp,esp
[00000c39][0025c1f2][0025c1f6] 8b4508 mov eax,[ebp+08]
[00000c3c][0025c1ee][00000c36] 50 push eax // push P
[00000c3d][0025c1ee][00000c36] 8b4d08 mov ecx,[ebp+08]
[00000c40][0025c1ea][00000c36] 51 push ecx // push P
[00000c41][0025c1e6][00000c46] e820fdffff call 00000966 // call H(P,P)
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

The above if from pages 4 and 5
Halting problem undecidability and infinitely nested simulation
May 2021 PL Olcott

https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

--
Copyright 2021 Pete Olcott

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

On 11/1/2021 5:50 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
> Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2
>
> No. H(P,P) == 0 is correct if, and only if, P(P) does not halt. But
> (according to you -- we are not allowed to see the full code) P(P)
> halts:
>

No matter what the code is for H every possible H must abort its
simulation of (P,P) otherwise this input never halts.

> || Here's the key question: do you still assert that H(P,P) == false is
> || the "correct" answer even though P(P) halts?
>

H(P,P) reports that its input never halts.
It is indeed a verified fact that its input never halts.
When you argue with verified facts you diverge from rationality.

H1(P,P) reports that P(P) halts.

Both are correct.

> | Yes that is the correct answer even though P(P) halts.
>
> No waffle can alter the fact that false (or 0 etc.) is the wrong return.
>

--
Copyright 2021 Pete Olcott

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

On 11/1/2021 9:28 AM, Ben Bacarisse wrote:
> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
>
>> On Monday, 1 November 2021 at 03:45:47 UTC, olcott wrote:
>>> // Simplified Linz Ĥ (Linz:1990:319)
>>> // Strachey(1965) CPL translated to C
>>> void P(u32 x)
>>> {
>>> if (H(x, x))
>>> HERE: goto HERE;
>>> }
>>>
>>> int main()
>>> {
>>> Output("Input_Halts = ", H((u32)P, (u32)P));
>>> }
>>>
>>> We can analyze H(P,P) at the very high level of abstraction of its two
>>> possible behaviors relative to its input allows us to concisely prove
>>> that not halting <is> the correct decision for this input. No matter how
>>> H works internally the only thing that counts is the behavior of its
>>> input for the two possible behaviors that H can have.
>>>
>>> Since the input to H(P,P) never reaches its final state for the two
>>> possible behaviors that every H can possibly have (abort the input or do
>>> not abort the input) then we can conclude that not halting is the
>>> correct decision for every possible simulating halt decider H.
>>>
>> I can see where the confusion lies. If H never aborts, it simulates P forever.
>> If it aborts, then it aborts because it has detected that otherwise P would
>> simulate forever.
>>
>> What you are forgetting is that P depends on H.
>
> What makes you think he's forgetting that? Having (at least) two
> different Hs without changing H^ (now called P) has been the ruse for
> months and months.
>
> His Halts function was declared correct because of what would happen if
> line 15 were commented out. It has always been some variation of the
> theme of "the wrong answer is right because of what would happen if H
> (but not H^) were not the function it really is".
>

No matter what the code is for H every possible H must abort its
simulation of (P,P) otherwise this input never halts.

Whether or not H(P,P) aborts its simulation of its input this input
reaches its final state, thus in all cases the input to H(P,P) never
reaches its final state thus in all cases the input to H(P,P) matches
the definition of not halting.

Now that I have generalized my proof such that this proof can be
directly applied to the Linz it is in a form that is in the ballpark of
what academic journals would accept.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
If the pure simulation of the input to Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ reaches Ĥ.qy

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
If the pure simulation of the input to Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ would never reach
Ĥ.qy or Ĥ.qn

Halting problem undecidability and infinitely nested simulation
May 2021 PL Olcott

https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

>> If H aborts, the P would also
>> abort i.e. terminate. So if H aborts P, it aborts incorrectly, despite the fact
>> that if it didn't abort, P would run forever.
>> That seems like a contradiction, but it isn't really, because we are talking
>> about two Ps, one with an H which never aborts, one with an H that
>> aborts.
>
> Do you think the change of name from a dependent one (H^) to one that
> hides the dependence (P) is an accident? Might is not be part of the
> scheme to find words that make the wrong answer, H(P,P) == false, seem
> less wrong despite the fact that P(P) halts?
>

--
Copyright 2021 Pete Olcott

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

On 11/1/2021 6:46 AM, Malcolm McLean wrote:
> On Monday, 1 November 2021 at 03:45:47 UTC, olcott wrote:

<SNIP POOP>

> I can see where the confusion lies. If H never aborts, it simulates P forever.
> If it aborts, then it aborts because it has detected that otherwise P would
> simulate forever.

Malcolm, note well: "confusion" does not lie; it's the permanently
self-bamboozled PO who lies.

<SNIP>
--
Humpty Dumpty

On 11/1/2021 11:31 AM, Jeff Barnett wrote:
> On 11/1/2021 6:46 AM, Malcolm McLean wrote:
>> On Monday, 1 November 2021 at 03:45:47 UTC, olcott wrote:
>
>      <SNIP POOP>
>
>> I can see where the confusion lies. If H never aborts, it simulates P
>> forever.
>> If it aborts, then it aborts because it has detected that otherwise P
>> would
>> simulate forever.
>
> Malcolm, note well: "confusion" does not lie; it's the permanently
> self-bamboozled PO who lies.
>
>       <SNIP>

The part that you quoted proves that I am correct, yet because you are
clueless about these things you don't see this. You have never ever
provided any reply what-so-ever (that I remember) that was anything at
all besides denigration. Ad Hominem is your only tool.

Ad Hominem
(Attacking the person): This fallacy occurs when, instead of addressing
someone's argument or position, you irrelevantly attack the person or
some aspect of the person who is making the argument.
https://www.txstate.edu/philosophy/resources/fallacy-definitions/Ad-Hominem.html

--
Copyright 2021 Pete Olcott

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

On 11/1/2021 10:46 AM, olcott wrote:
> On 11/1/2021 11:31 AM, Jeff Barnett wrote:
>> On 11/1/2021 6:46 AM, Malcolm McLean wrote:
>>> On Monday, 1 November 2021 at 03:45:47 UTC, olcott wrote:
>>
>>       <SNIP POOP>
>>
>>> I can see where the confusion lies. If H never aborts, it simulates P
>>> forever.
>>> If it aborts, then it aborts because it has detected that otherwise P
>>> would
>>> simulate forever.
>>
>> Malcolm, note well: "confusion" does not lie; it's the permanently
>> self-bamboozled PO who lies.
>>
>>        <SNIP>
>
> The part that you quoted proves that I am correct, yet because you are
> clueless about these things you don't see this. You have never ever
> provided any reply what-so-ever (that I remember) that was anything at
> all besides denigration. Ad Hominem is your only tool.
>
> Ad Hominem
> (Attacking the person): This fallacy occurs when, instead of addressing
> someone's argument or position, you irrelevantly attack the person or
> some aspect of the person who is making the argument.
> https://www.txstate.edu/philosophy/resources/fallacy-definitions/Ad-Hominem.html
So this is your refutation by cut & paste and/or cite to an article you
do not understand. Ergo, self-bamboozled one, an argument by "Ad
Hominem"! I know you wont understand this point or you wouldn't have
posted this response. So that your finger pointing - now pointed at you
- doesn't poke you in the eye, you must give logical reasons why either
1) confusions lie or 2) or you don't. I suggest that you try to deal
with point 1; point 2 has been established beyond a doubt.
Let me put this another way that even an ignoramus like you just might
understand, you are either highly delusional or wrongly think you are
the most clever fellow on the block. In either case there is an element
of self delusion involved with your behavior. In other words, reporting
obvious facts about you is not Ad anything. It's a simple instance of
the empirical science method where one reports what they have carefully
observed.
As one who bares you no ill will, I suggest that you get the help you
need both mentally and physically. If your goal is merely to do
something that will cause people to remember you fondly and with
admiration, I have some suggestions: 1) put on a mask and read stories
to young children in your neighborhood, 2) adopt a feral kitten or puppy
- maybe several - and try to find them homes, 3) do some volunteer work
at a local hospital or "retirement" home. Do give up this foray into
math, logic, and philosophy. You have no talent for it. The only
reputation that will survive you is that of an arrogant self deluded
fool if you continue down this path.
I'm sorry that this is as close to a positive message as I can give you.
You have closed the doors to any more warm and helpful interactions with
others. Rethink your approach to life and seek peace.
--
Jeff Barnett

On 11/1/2021 3:33 PM, Jeff Barnett wrote:
> On 11/1/2021 10:46 AM, olcott wrote:
>> On 11/1/2021 11:31 AM, Jeff Barnett wrote:
>>> On 11/1/2021 6:46 AM, Malcolm McLean wrote:
>>>> On Monday, 1 November 2021 at 03:45:47 UTC, olcott wrote:
>>>
>>>       <SNIP POOP>
>>>
>>>> I can see where the confusion lies. If H never aborts, it simulates
>>>> P forever.
>>>> If it aborts, then it aborts because it has detected that otherwise
>>>> P would
>>>> simulate forever.
>>>
>>> Malcolm, note well: "confusion" does not lie; it's the permanently
>>> self-bamboozled PO who lies.
>>>
>>>        <SNIP>
>>
>> The part that you quoted proves that I am correct, yet because you are
>> clueless about these things you don't see this. You have never ever
>> provided any reply what-so-ever (that I remember) that was anything at
>> all besides denigration. Ad Hominem is your only tool.
>>
>> Ad Hominem
>> (Attacking the person): This fallacy occurs when, instead of
>> addressing someone's argument or position, you irrelevantly attack the
>> person or some aspect of the person who is making the argument.
>> https://www.txstate.edu/philosophy/resources/fallacy-definitions/Ad-Hominem.html
>
>
> So this is your refutation

There is nothing to refute all that you ever have is denigration.

--
Copyright 2021 Pete Olcott

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

olcott <NoOne@NoWhere.com> writes:

>> || Here's the key question: do you still assert that H(P,P) == false is
>> || the "correct" answer even though P(P) halts?

To which you replied (but have for some reason cut from this post)

>> | Yes that is the correct answer even though P(P) halts.

> H(P,P) reports that its input never halts.

H(P,P) should report on whether P(P) halts. Stating that the wrong
answer is the right one is not how mathematics is done.

--
Ben.

olcott <NoOne@NoWhere.com> writes:

> Now that I have generalized my proof such that this proof can be
> directly applied to the Linz it is in a form that is in the ballpark
> of what academic journals would accept.

What proof? You appear to be simply making ill-defined and incorrect
statement about the TMs defined in Linz.

> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> If the pure simulation of the input to Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ reaches Ĥ.qy

This is so wrong I don't know where to start. But the key thing to
remember is that the correct condition for this line is "if Ĥ applied to
⟨Ĥ⟩ halts" so we don't need to find out what you are trying to say.

> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> If the pure simulation of the input to Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ would never reach
> Ĥ.qy or Ĥ.qn

Again, wildly wrong. The correct condition is "if Ĥ applied to ⟨Ĥ⟩ does
not halt".

Remember you use Ĥ to mean the same class of TMs that Linz does.
Removing the essential defining conditions for that class of TMs is just
being dishonest.

--
Ben.

On 11/1/21 10:48 AM, olcott wrote:
> On 11/1/2021 7:46 AM, Malcolm McLean wrote:
>> On Monday, 1 November 2021 at 03:45:47 UTC, olcott wrote:
>>> // Simplified Linz Ĥ (Linz:1990:319)
>>> // Strachey(1965) CPL translated to C
>>> void P(u32 x)
>>> {
>>> if (H(x, x))
>>> HERE: goto HERE;
>>> }
>>>
>>> int main()
>>> {
>>> Output("Input_Halts = ", H((u32)P, (u32)P));
>>> }
>>>
>>> We can analyze H(P,P) at the very high level of abstraction of its two
>>> possible behaviors relative to its input allows us to concisely prove
>>> that not halting <is> the correct decision for this input. No matter how
>>> H works internally the only thing that counts is the behavior of its
>>> input for the two possible behaviors that H can have.
>>>
>>> Since the input to H(P,P) never reaches its final state for the two
>>> possible behaviors that every H can possibly have (abort the input or do
>>> not abort the input) then we can conclude that not halting is the
>>> correct decision for every possible simulating halt decider H.
>>>
>> I can see where the confusion lies. If H never aborts, it simulates P
>> forever.
>> If it aborts, then it aborts because it has detected that otherwise P
>> would
>> simulate forever.
>>
>> What you are forgetting is that P depends on H. If H aborts, the P
>> would also
>> abort i.e. terminate. So if H aborts P, it aborts incorrectly, despite
>> the fact
>> that if it didn't abort, P would run forever.
>> That seems like a contradiction, but it isn't really, because we are
>> talking
>> about two Ps, one with an H which never aborts, one with an H that
>> aborts.
>>
>
> void Infinite_Loop()
> {
>   HERE: goto HERE;
> }
>
> _Infinite_Loop()
> [00000ab0](01)  55              push ebp
> [00000ab1](02)  8bec            mov ebp,esp
> [00000ab3](02)  ebfe            jmp 00000ab3
> [00000ab5](01)  5d              pop ebp
> [00000ab6](01)  c3              ret
> Size in bytes:(0007) [00000ab6]
>
> If H allows Infinite_Loop() to continue then Infinite_Loop() never
> reaches its final state of 0xab6. If H aborts its simulation of
> Infinite_Loop() then it stops at 0xab3 and never reaches its final state
> of 0xab6. H(P,P) is the same situation:

No, H's simulation stops at 0xab3.

P goes on and at the next call to H, the H called by the top level P
aborts its simulation, returns non-halting, and P then Halts.

Thus P(P) is Halting and H abort its simulation and answered non-halting
incorrectly.

Do you deny that this is what would happen if this exact same input was
given to a UTM.

>
> We are talking about this case shown below which conclusively proves
> that every simulating halt decider H must abort its simulation its input
> otherwise (just like the infinite loop shown above) its input never halts.
>
> Aborting the input does not count as halting because the input never
> reaches its final state no matter what H does. Any input that never
> reaches its final state NO MATTER WHAT is an input that never halts.
>
> // Simplified Linz Ĥ (Linz:1990:319)
> // Strachey(1965) CPL translated to C
> void P(u32 x)
> {
>   if (H(x, x))
>     HERE: goto HERE;
> }
>
> int main()
> {
>   Output("Input_Halts = ", H((u32)P, (u32)P));
> }
>
> _P()
> [00000c36](01)  55          push ebp
> [00000c37](02)  8bec        mov ebp,esp
> [00000c39](03)  8b4508      mov eax,[ebp+08] // 2nd Param
> [00000c3c](01)  50          push eax
> [00000c3d](03)  8b4d08      mov ecx,[ebp+08] // 1st Param
> [00000c40](01)  51          push ecx
> [00000c41](05)  e820fdffff  call 00000966    // call H
> [00000c46](03)  83c408      add esp,+08
> [00000c49](02)  85c0        test eax,eax
> [00000c4b](02)  7402        jz 00000c4f
> [00000c4d](02)  ebfe        jmp 00000c4d
> [00000c4f](01)  5d          pop ebp
> [00000c50](01)  c3          ret
> Size in bytes:(0027) [00000c50]
>
> _main()
> [00000c56](01)  55          push ebp
> [00000c57](02)  8bec        mov ebp,esp
> [00000c59](05)  68360c0000  push 00000c36    // push P
> [00000c5e](05)  68360c0000  push 00000c36    // push P
> [00000c63](05)  e8fefcffff  call 00000966    // call H(P,P)
> [00000c68](03)  83c408      add esp,+08
> [00000c6b](01)  50          push eax
> [00000c6c](05)  6857030000  push 00000357
> [00000c71](05)  e810f7ffff  call 00000386
> [00000c76](03)  83c408      add esp,+08
> [00000c79](02)  33c0        xor eax,eax
> [00000c7b](01)  5d          pop ebp
> [00000c7c](01)  c3          ret
> Size in bytes:(0039) [00000c7c]
>
>  machine   stack     stack     machine    assembly
>  address   address   data      code       language
>  ========  ========  ========  =========  =============
> [00000c56][0010172a][00000000] 55          push ebp
> [00000c57][0010172a][00000000] 8bec        mov ebp,esp
> [00000c59][00101726][00000c36] 68360c0000  push 00000c36 // push P
> [00000c5e][00101722][00000c36] 68360c0000  push 00000c36 // push P
> [00000c63][0010171e][00000c68] e8fefcffff  call 00000966 // call H(P,P)
>
> Begin Local Halt Decider Simulation at Machine Address:c36
> [00000c36][002117ca][002117ce] 55          push ebp
> [00000c37][002117ca][002117ce] 8bec        mov ebp,esp
> [00000c39][002117ca][002117ce] 8b4508      mov eax,[ebp+08]
> [00000c3c][002117c6][00000c36] 50          push eax       // push P
> [00000c3d][002117c6][00000c36] 8b4d08      mov ecx,[ebp+08]
> [00000c40][002117c2][00000c36] 51          push ecx       // push P
> [00000c41][002117be][00000c46] e820fdffff  call 00000966  // call H(P,P)
>
> [00000c36][0025c1f2][0025c1f6] 55          push ebp
> [00000c37][0025c1f2][0025c1f6] 8bec        mov ebp,esp
> [00000c39][0025c1f2][0025c1f6] 8b4508      mov eax,[ebp+08]
> [00000c3c][0025c1ee][00000c36] 50          push eax       // push P
> [00000c3d][0025c1ee][00000c36] 8b4d08      mov ecx,[ebp+08]
> [00000c40][0025c1ea][00000c36] 51          push ecx       // push P
> [00000c41][0025c1e6][00000c46] e820fdffff  call 00000966  // call H(P,P)
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>
>
> The above if from pages 4 and 5
> Halting problem undecidability and infinitely nested simulation
> May 2021 PL Olcott
>
> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>
>
>
>

On 11/1/21 10:54 AM, olcott wrote:
> On 11/1/2021 5:50 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>> Subject: Re: H(P,P)==0 is correct for every simulating halt decider H
>> --- V2
>>
>> No.  H(P,P) == 0 is correct if, and only if, P(P) does not halt.  But
>> (according to you -- we are not allowed to see the full code) P(P)
>> halts:
>>
>
> No matter what the code is for H every possible H must abort its
> simulation of (P,P) otherwise this input never halts.
>
>> || Here's the key question: do you still assert that H(P,P) == false is
>> || the "correct" answer even though P(P) halts?
>>
>
> H(P,P) reports that its input never halts.

Right, the input to H doesn't halt. It also doesn't not-halt, because
Halting isn't a property of the symbol string of an 'input'

Halting is a property of a Computaiton.

The input to H happens to be the representattion of a Computation, and
it is that Computation that H is supposed to be answering about, so when
we evaluate H(P,P), its answer is supposed to correspond to the behavior
of the Computation P(P).

An alternative view, would be to say that we look at what happens when
this input is provided to a UTM to simulate, and that, by the definition
of what a UTM is, will be exactly that same answer.

The one thing it does NOT mean, which you seem to be trying to claim, is
what happens in a partial simulation done by the machine H.

> It is indeed a verified fact that its input never halts.
> When you argue with verified facts you diverge from rationality.

Nope, that is a NONSENSE statement.

Is the Color Black a Cat?

Does the Color Black Halt?

Those questions make as much sense as the question
'Does the input halt?'

>
> H1(P,P) reports that P(P) halts.

So what, H1 is a different computation. H is the one that needs to get
the right answer, which it doesn't.
>
> Both are correct.

They CAN'T both be correct!!!!

BOTH machines are supposedly answering the EXACT SAME QUESTION, does the
ACTUAL COMPUTATION P(P) Halt or not.

Your claim that both are correct shows that you don't understand the
basics of what you are talking about.

>
>> | Yes that is the correct answer even though P(P) halts.
>>
>> No waffle can alter the fact that false (or 0 etc.) is the wrong return.
>>
>
>

On 11/1/21 6:39 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> Now that I have generalized my proof such that this proof can be
>> directly applied to the Linz it is in a form that is in the ballpark
>> of what academic journals would accept.
>
> What proof? You appear to be simply making ill-defined and incorrect
> statement about the TMs defined in Linz.
>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> If the pure simulation of the input to Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ reaches Ĥ.qy
>
> This is so wrong I don't know where to start. But the key thing to
> remember is that the correct condition for this line is "if Ĥ applied to
> ⟨Ĥ⟩ halts" so we don't need to find out what you are trying to say.

Actually, if we use this statement to see that PO is using 'Pure
Simulation' to mean Simulated by a UTM, then by the definition of a UTM,
the 'Pure Simulation of the input to H^.qx', since that input is <H^>
<H^> is exactly equivalent to H^ applied to <H^>.

The key point he misses is that there is no such thing as being exactly
like a UTM and stopping the simulation before it ends.

If H does 'abort' its simulation, then what it did is NOT the equivalent
of a UTM, and thus is NOT a 'Pure Simulation'

>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>> If the pure simulation of the input to Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ would never reach
>> Ĥ.qy or Ĥ.qn
>
> Again, wildly wrong. The correct condition is "if Ĥ applied to ⟨Ĥ⟩ does
> not halt".

If a REAL Pure simulation, as defined above, has the simulation of the
input to H^.qx/H not reaching a terminal state, then yes, that input is
non-halting. The problem is that if this is true, then we can show that
H applies to <H^> <H^> can NOT reach qn and get the answer correctly,
because if H.q0 <H^> <H^> -> H.qn then because they are the exact same
code, H^.qx <H^> <H^> must ALSO get to H^.qn which halts, so the initial
stipulation that the pure simulation did not halt.

>
> Remember you use Ĥ to mean the same class of TMs that Linz does.
> Removing the essential defining conditions for that class of TMs is just
> being dishonest.
>

On 11/1/2021 3:22 PM, olcott wrote:
> On 11/1/2021 3:33 PM, Jeff Barnett wrote:
>> On 11/1/2021 10:46 AM, olcott wrote:
>>> On 11/1/2021 11:31 AM, Jeff Barnett wrote:
>>>> On 11/1/2021 6:46 AM, Malcolm McLean wrote:
>>>>> On Monday, 1 November 2021 at 03:45:47 UTC, olcott wrote:
>>>>
>>>>       <SNIP POOP>
>>>>
>>>>> I can see where the confusion lies. If H never aborts, it simulates
>>>>> P forever.
>>>>> If it aborts, then it aborts because it has detected that otherwise
>>>>> P would
>>>>> simulate forever.
>>>>
>>>> Malcolm, note well: "confusion" does not lie; it's the permanently
>>>> self-bamboozled PO who lies.
>>>>
>>>>        <SNIP>
>>>
>>> The part that you quoted proves that I am correct, yet because you
>>> are clueless about these things you don't see this. You have never
>>> ever provided any reply what-so-ever (that I remember) that was
>>> anything at all besides denigration. Ad Hominem is your only tool.
>>>
>>> Ad Hominem
>>> (Attacking the person): This fallacy occurs when, instead of
>>> addressing someone's argument or position, you irrelevantly attack
>>> the person or some aspect of the person who is making the argument.
>>> https://www.txstate.edu/philosophy/resources/fallacy-definitions/Ad-Hominem.html
>>
>>
>>
>> So this is your refutation
>
> There is nothing to refute all that you ever have is denigration.
I see you cut all of my message except for the first line. I also
noticed that you didn't expand the newsgroup list to the normal ones.
Why not? Would it embarrass you? Some hints about how to face your
unhappy life and improve your existence? You really are a befuddled
buffoon choosing to live with the label of proud ignoramus tattooed on
your forehead. Unfortunately nothing you can or will say could change
your now permanent reputation.
--
Jeff Barnett

On 11/1/2021 8:31 PM, Jeff Barnett wrote:
> On 11/1/2021 3:22 PM, olcott wrote:
>> On 11/1/2021 3:33 PM, Jeff Barnett wrote:
>>> On 11/1/2021 10:46 AM, olcott wrote:
>>>> On 11/1/2021 11:31 AM, Jeff Barnett wrote:
>>>>> On 11/1/2021 6:46 AM, Malcolm McLean wrote:
>>>>>> On Monday, 1 November 2021 at 03:45:47 UTC, olcott wrote:
>>>>>
>>>>>       <SNIP POOP>
>>>>>
>>>>>> I can see where the confusion lies. If H never aborts, it
>>>>>> simulates P forever.
>>>>>> If it aborts, then it aborts because it has detected that
>>>>>> otherwise P would
>>>>>> simulate forever.
>>>>>
>>>>> Malcolm, note well: "confusion" does not lie; it's the permanently
>>>>> self-bamboozled PO who lies.
>>>>>
>>>>>        <SNIP>
>>>>
>>>> The part that you quoted proves that I am correct, yet because you
>>>> are clueless about these things you don't see this. You have never
>>>> ever provided any reply what-so-ever (that I remember) that was
>>>> anything at all besides denigration. Ad Hominem is your only tool.
>>>>
>>>> Ad Hominem
>>>> (Attacking the person): This fallacy occurs when, instead of
>>>> addressing someone's argument or position, you irrelevantly attack
>>>> the person or some aspect of the person who is making the argument.
>>>> https://www.txstate.edu/philosophy/resources/fallacy-definitions/Ad-Hominem.html
>>>
>>>
>>>
>>>
>>> So this is your refutation
>>
>> There is nothing to refute all that you ever have is denigration.
>
> I see you cut all of my message except for the first line. I also
> noticed that you didn't expand the newsgroup list to the normal ones.
> Why not? Would it embarrass you? Some hints about how to face your
> unhappy life and improve your existence? You really are a befuddled
> buffoon choosing to live with the label of proud ignoramus tattooed on
> your forehead. Unfortunately nothing you can or will say could change
> your now permanent reputation.

You apparently simply choose to be a jackass at least towards me.
This will be quite embarrassing for you when my work is accepted as correct.

--
Copyright 2021 Pete Olcott "Great spirits have always encountered
violent opposition from mediocre minds." Einstein

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

> On 11/1/21 6:39 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> Now that I have generalized my proof such that this proof can be
>>> directly applied to the Linz it is in a form that is in the ballpark
>>> of what academic journals would accept.
>> What proof? You appear to be simply making ill-defined and incorrect
>> statement about the TMs defined in Linz.
>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> If the pure simulation of the input to Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ reaches Ĥ.qy
>> This is so wrong I don't know where to start. But the key thing to
>> remember is that the correct condition for this line is "if Ĥ applied to
>> ⟨Ĥ⟩ halts" so we don't need to find out what you are trying to say.
>
> Actually, if we use this statement to see that PO is using 'Pure
> Simulation' to mean Simulated by a UTM, then by the definition of a
> UTM, the 'Pure Simulation of the input to H^.qx', since that input is
> <H^> <H^> is exactly equivalent to H^ applied to <H^>.

That is one interpretation. It's a silly thing for him to say because
of course H^ applied to <H^> transitions to H^.qy if H^ applied to <H^>
transitions to H^.qy. But, true or not, it's still the wrong condition
for that line.

But why do think that's what he meant? He says "the simulation" not "a
simulation" so I suspect he's really thinking about the simulation
embedded in H^, not just what any arbitrary UTM would do, and as you
point out, that's not a pure simulation.

And if he means what you think (and it was my best guess too) we can be
certain of one thing -- the simulation won't reach state H^.qy. At best
it reaches some configuration that represents H^.qy in the UTM. But
that's detail, and he does not do details.

The whole condition is a mess. I prefer to ignore the mess and just
point out that it's not what Linz's H^ is defined to do. While he
maintains that he always uses H^ to mean what Linz does, I plan to keep
pointing out that he's dishonestly removing a key condition.

But you like to get into that sort of thing with him, and that's fine.
He can be wrong in many different ways.

--
Ben.

On 11/1/21 11:25 PM, Ben Bacarisse wrote:
> Richard Damon <Richard@Damon-Family.org> writes:
>
>> On 11/1/21 6:39 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> Now that I have generalized my proof such that this proof can be
>>>> directly applied to the Linz it is in a form that is in the ballpark
>>>> of what academic journals would accept.
>>> What proof? You appear to be simply making ill-defined and incorrect
>>> statement about the TMs defined in Linz.
>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> If the pure simulation of the input to Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ reaches Ĥ.qy
>>> This is so wrong I don't know where to start. But the key thing to
>>> remember is that the correct condition for this line is "if Ĥ applied to
>>> ⟨Ĥ⟩ halts" so we don't need to find out what you are trying to say.
>>
>> Actually, if we use this statement to see that PO is using 'Pure
>> Simulation' to mean Simulated by a UTM, then by the definition of a
>> UTM, the 'Pure Simulation of the input to H^.qx', since that input is
>> <H^> <H^> is exactly equivalent to H^ applied to <H^>.
>
> That is one interpretation. It's a silly thing for him to say because
> of course H^ applied to <H^> transitions to H^.qy if H^ applied to <H^>
> transitions to H^.qy. But, true or not, it's still the wrong condition
> for that line.
>
> But why do think that's what he meant? He says "the simulation" not "a
> simulation" so I suspect he's really thinking about the simulation
> embedded in H^, not just what any arbitrary UTM would do, and as you
> point out, that's not a pure simulation.
>
> And if he means what you think (and it was my best guess too) we can be
> certain of one thing -- the simulation won't reach state H^.qy. At best
> it reaches some configuration that represents H^.qy in the UTM. But
> that's detail, and he does not do details.
>
> The whole condition is a mess. I prefer to ignore the mess and just
> point out that it's not what Linz's H^ is defined to do. While he
> maintains that he always uses H^ to mean what Linz does, I plan to keep
> pointing out that he's dishonestly removing a key condition.
>
> But you like to get into that sort of thing with him, and that's fine.
> He can be wrong in many different ways.
>

Yes, he calls it 'the simulation' as it is the only one that he sees,
and he likes to call it a 'Pure Simulation until ...' as if that makes
it meet the actual requirements of a REAL UTM Simulation (which it doesn't).

This is just an example of him not understand what things actually mean
and then using shifting definitions to try to 'prove' his statements.

He knows that answer that he wants to get, and he doesn't let 'truth'
get in his way to try to 'prove' what he wants to get to. Not knowing
what things actually mean allows him to invent wrong/sloppy meanings to
do this.

On 11/1/2021 8:04 PM, olcott wrote:
> On 11/1/2021 8:31 PM, Jeff Barnett wrote:
>> On 11/1/2021 3:22 PM, olcott wrote:
>>> On 11/1/2021 3:33 PM, Jeff Barnett wrote:
>>>> On 11/1/2021 10:46 AM, olcott wrote:
>>>>> On 11/1/2021 11:31 AM, Jeff Barnett wrote:
>>>>>> On 11/1/2021 6:46 AM, Malcolm McLean wrote:
>>>>>>> On Monday, 1 November 2021 at 03:45:47 UTC, olcott wrote:
>>>>>>
>>>>>>       <SNIP POOP>
>>>>>>
>>>>>>> I can see where the confusion lies. If H never aborts, it
>>>>>>> simulates P forever.
>>>>>>> If it aborts, then it aborts because it has detected that
>>>>>>> otherwise P would
>>>>>>> simulate forever.
>>>>>>
>>>>>> Malcolm, note well: "confusion" does not lie; it's the permanently
>>>>>> self-bamboozled PO who lies.
>>>>>>
>>>>>>        <SNIP>
>>>>>
>>>>> The part that you quoted proves that I am correct, yet because you
>>>>> are clueless about these things you don't see this. You have never
>>>>> ever provided any reply what-so-ever (that I remember) that was
>>>>> anything at all besides denigration. Ad Hominem is your only tool.
>>>>>
>>>>> Ad Hominem
>>>>> (Attacking the person): This fallacy occurs when, instead of
>>>>> addressing someone's argument or position, you irrelevantly attack
>>>>> the person or some aspect of the person who is making the argument.
>>>>> https://www.txstate.edu/philosophy/resources/fallacy-definitions/Ad-Hominem.html
>>>>
>>>>
>>>>
>>>>
>>>>
>>>> So this is your refutation
>>>
>>> There is nothing to refute all that you ever have is denigration.
>>
>> I see you cut all of my message except for the first line. I also
>> noticed that you didn't expand the newsgroup list to the normal ones.
>> Why not? Would it embarrass you? Some hints about how to face your
>> unhappy life and improve your existence? You really are a befuddled
>> buffoon choosing to live with the label of proud ignoramus tattooed on
>> your forehead. Unfortunately nothing you can or will say could change
>> your now permanent reputation.
>
> You apparently simply choose to be a jackass at least towards me.
> This will be quite embarrassing for you when my work is accepted as
> correct.
You correct on any of the many topics in this newsgroup!!??!? Don't make
me laugh. The only notable scientific thing to your credit is the record
for longest consecutive string of thinking errors. You've been at it for
more than a decade and haven't been right once. Not Ad Homiem; fact!
Don't you just love these Latin phrases?
--
Jeff Barnett

On 11/1/2021 11:08 PM, Jeff Barnett wrote:
> On 11/1/2021 8:04 PM, olcott wrote:
>> On 11/1/2021 8:31 PM, Jeff Barnett wrote:
>>> On 11/1/2021 3:22 PM, olcott wrote:
>>>> On 11/1/2021 3:33 PM, Jeff Barnett wrote:
>>>>> On 11/1/2021 10:46 AM, olcott wrote:
>>>>>> On 11/1/2021 11:31 AM, Jeff Barnett wrote:
>>>>>>> On 11/1/2021 6:46 AM, Malcolm McLean wrote:
>>>>>>>> On Monday, 1 November 2021 at 03:45:47 UTC, olcott wrote:
>>>>>>>
>>>>>>>       <SNIP POOP>
>>>>>>>
>>>>>>>> I can see where the confusion lies. If H never aborts, it
>>>>>>>> simulates P forever.
>>>>>>>> If it aborts, then it aborts because it has detected that
>>>>>>>> otherwise P would
>>>>>>>> simulate forever.
>>>>>>>
>>>>>>> Malcolm, note well: "confusion" does not lie; it's the
>>>>>>> permanently self-bamboozled PO who lies.
>>>>>>>
>>>>>>>        <SNIP>
>>>>>>
>>>>>> The part that you quoted proves that I am correct, yet because you
>>>>>> are clueless about these things you don't see this. You have never
>>>>>> ever provided any reply what-so-ever (that I remember) that was
>>>>>> anything at all besides denigration. Ad Hominem is your only tool.
>>>>>>
>>>>>> Ad Hominem
>>>>>> (Attacking the person): This fallacy occurs when, instead of
>>>>>> addressing someone's argument or position, you irrelevantly attack
>>>>>> the person or some aspect of the person who is making the argument.
>>>>>> https://www.txstate.edu/philosophy/resources/fallacy-definitions/Ad-Hominem.html
>>>>>
>>>>>
>>>>>
>>>>>
>>>>>
>>>>>
>>>>> So this is your refutation
>>>>
>>>> There is nothing to refute all that you ever have is denigration.
>>>
>>> I see you cut all of my message except for the first line. I also
>>> noticed that you didn't expand the newsgroup list to the normal ones.
>>> Why not? Would it embarrass you? Some hints about how to face your
>>> unhappy life and improve your existence? You really are a befuddled
>>> buffoon choosing to live with the label of proud ignoramus tattooed
>>> on your forehead. Unfortunately nothing you can or will say could
>>> change your now permanent reputation.
>>
>> You apparently simply choose to be a jackass at least towards me.
>> This will be quite embarrassing for you when my work is accepted as
>> correct.
>
> You correct on any of the many topics in this newsgroup!!??!? Don't make
> me laugh. The only notable scientific thing to your credit is the record
> for longest consecutive string of thinking errors. You've been at it for
> more than a decade and haven't been right once. Not Ad Homiem; fact!
> Don't you just love these Latin phrases?

ad hominem
You attacked your opponent's character or personal traits in an attempt
to undermine their argument. https://yourlogicalfallacyis.com/ad-hominem

--
Copyright 2021 Pete Olcott "Great spirits have always encountered
violent opposition from mediocre minds." Einstein

On 11/1/2021 5:38 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>>> || Here's the key question: do you still assert that H(P,P) == false is
>>> || the "correct" answer even though P(P) halts?
>
> To which you replied (but have for some reason cut from this post)
>
>>> | Yes that is the correct answer even though P(P) halts.
>
>> H(P,P) reports that its input never halts.
>
> H(P,P) should report on whether P(P) halts. Stating that the wrong
> answer is the right one is not how mathematics is done.
>

H1(P,P) is computationally equivalent to P(P).
H(P,P) is not computationally equivalent to P(P).

--
Copyright 2021 Pete Olcott

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

On 11/1/2021 11:08 PM, Jeff Barnett wrote:
> On 11/1/2021 8:04 PM, olcott wrote:
>> On 11/1/2021 8:31 PM, Jeff Barnett wrote:
>>> On 11/1/2021 3:22 PM, olcott wrote:
>>>> On 11/1/2021 3:33 PM, Jeff Barnett wrote:
>>>>> On 11/1/2021 10:46 AM, olcott wrote:
>>>>>> On 11/1/2021 11:31 AM, Jeff Barnett wrote:
>>>>>>> On 11/1/2021 6:46 AM, Malcolm McLean wrote:
>>>>>>>> On Monday, 1 November 2021 at 03:45:47 UTC, olcott wrote:
>>>>>>>
>>>>>>>       <SNIP POOP>
>>>>>>>
>>>>>>>> I can see where the confusion lies. If H never aborts, it
>>>>>>>> simulates P forever.
>>>>>>>> If it aborts, then it aborts because it has detected that
>>>>>>>> otherwise P would
>>>>>>>> simulate forever.
>>>>>>>
>>>>>>> Malcolm, note well: "confusion" does not lie; it's the
>>>>>>> permanently self-bamboozled PO who lies.
>>>>>>>
>>>>>>>        <SNIP>
>>>>>>
>>>>>> The part that you quoted proves that I am correct, yet because you
>>>>>> are clueless about these things you don't see this. You have never
>>>>>> ever provided any reply what-so-ever (that I remember) that was
>>>>>> anything at all besides denigration. Ad Hominem is your only tool.
>>>>>>
>>>>>> Ad Hominem
>>>>>> (Attacking the person): This fallacy occurs when, instead of
>>>>>> addressing someone's argument or position, you irrelevantly attack
>>>>>> the person or some aspect of the person who is making the argument.
>>>>>> https://www.txstate.edu/philosophy/resources/fallacy-definitions/Ad-Hominem.html
>>>>>
>>>>>
>>>>>
>>>>>
>>>>>
>>>>>
>>>>> So this is your refutation
>>>>
>>>> There is nothing to refute all that you ever have is denigration.
>>>
>>> I see you cut all of my message except for the first line. I also
>>> noticed that you didn't expand the newsgroup list to the normal ones.
>>> Why not? Would it embarrass you? Some hints about how to face your
>>> unhappy life and improve your existence? You really are a befuddled
>>> buffoon choosing to live with the label of proud ignoramus tattooed
>>> on your forehead. Unfortunately nothing you can or will say could
>>> change your now permanent reputation.
>>
>> You apparently simply choose to be a jackass at least towards me.
>> This will be quite embarrassing for you when my work is accepted as
>> correct.
>
> You correct on any of the many topics in this newsgroup!!??!? Don't make
> me laugh. The only notable scientific thing to your credit is the record
> for longest consecutive string of thinking errors. You've been at it for
> more than a decade and haven't been right once. Not Ad Homiem; fact!
> Don't you just love these Latin phrases?

ad hominem
You attacked your opponent's character or personal traits in an attempt
to undermine their argument. https://yourlogicalfallacyis.com/ad-hominem

--
Copyright 2021 Pete Olcott

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