On 5/24/2022 4:49 PM, Dennis Bush wrote:
> On Tuesday, May 24, 2022 at 5:15:55 PM UTC-4, olcott wrote:
>> On 5/24/2022 4:00 PM, Dennis Bush wrote:
>>> On Tuesday, May 24, 2022 at 4:47:15 PM UTC-4, olcott wrote:
>>>> On 5/24/2022 3:19 PM, Dennis Bush wrote:
>>>>> On Tuesday, May 24, 2022 at 4:04:05 PM UTC-4, olcott wrote:
>>>>>> On 5/24/2022 2:50 PM, Dennis Bush wrote:
>>>>>>> On Tuesday, May 24, 2022 at 3:40:47 PM UTC-4, olcott wrote:
>>>>>>>> On 5/24/2022 2:32 PM, Dennis Bush wrote:
>>>>>>>>> On Tuesday, May 24, 2022 at 3:20:40 PM UTC-4, olcott wrote:
>>>>>>>>>> On 5/24/2022 2:06 PM, Dennis Bush wrote:
>>>>>>>>>>> On Tuesday, May 24, 2022 at 2:56:35 PM UTC-4, olcott wrote:
>>>>>>>>>>>> On 5/24/2022 1:45 PM, Dennis Bush wrote:
>>>>>>>>>>>>> On Tuesday, May 24, 2022 at 2:29:07 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>> On 5/24/2022 1:20 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Tuesday, May 24, 2022 at 2:04:55 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>> On 5/24/2022 12:57 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>> On Tuesday, May 24, 2022 at 1:44:22 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>> On 5/24/2022 11:54 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>> On Tuesday, May 24, 2022 at 12:25:56 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 5/24/2022 11:22 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>> On Tuesday, May 24, 2022 at 12:18:21 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 5/24/2022 11:15 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, May 24, 2022 at 11:59:47 AM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 5/24/2022 10:25 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, May 24, 2022 at 10:57:12 AM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/24/2022 9:47 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, May 24, 2022 at 10:19:28 AM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/24/2022 8:57 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Monday, May 23, 2022 at 11:47:56 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/23/2022 10:16 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Monday, May 23, 2022 at 11:08:54 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/23/2022 10:05 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Monday, May 23, 2022 at 11:01:56 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/23/2022 9:57 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Monday, May 23, 2022 at 10:48:39 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/23/2022 9:40 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Monday, May 23, 2022 at 10:32:55 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/23/2022 9:23 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Monday, May 23, 2022 at 10:18:37 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/23/2022 9:09 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Monday, May 23, 2022 at 9:50:28 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/23/2022 8:40 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/23/22 9:34 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/23/2022 8:29 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Monday, May 23, 2022 at 9:24:47 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/23/2022 8:15 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Monday, May 23, 2022 at 9:08:54 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/23/2022 8:05 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Monday, May 23, 2022 at 8:57:46 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/23/2022 7:44 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Monday, May 23, 2022 at 7:50:36 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/23/2022 6:33 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/23/22 3:05 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/23/2022 1:52 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A simple multiple choice question for Olcott:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All things being equal which is more likely:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) Olcott is correct and everybody else is incorrect
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) Olcott is incorrect and everybody else is correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Believability has the word [lie] embedded directly within
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> itself.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Instead of the fake measure of credibility one must employ
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> validation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Actual validation conclusively proves that H(P,P)==0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is correct. This means that everyone that disagrees is either
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> insufficiently technically competent or a liar.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You consider that H(P,P) == 0 is correct when P(P) halts,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when that is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the DEFINITION of what H(P,P) is supposed to be answering?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The C function H correctly determines that there are no number
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of steps
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (0 to infinity) of its correct simulation of its input: a pair of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pointers to finite strings of x86 machine language that would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ever reach
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the last instruction of this input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But since H has a fixed algorithm, it can't simulate for an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite number of steps. It can only simulate P for some n
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> number of steps.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> None-the-less on the basis of matching known behavior patterns H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determine what the behavior of the input would be if it did
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulate an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite number of steps.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So because Pn(Pn) does not halt then Ha(Pa,Pa)==0 is correct?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No jackass, infinite loop does not halt because infinite loop is an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite loop.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012c2](01) 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012c3](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012c5](02) ebfe jmp 000012c5
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012c7](01) 5d pop ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [000012c8](01) c3 ret
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0007) [000012
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Irrelevant, because this isn't part of any P.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It not irrelevant jackass it proves that H can detect that an infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation would never halt without performing an infinite simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> An infinite loop and the infinite simulation in Pn(Pn) are different,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It sure is _Infinite_Loop() is on topic and H(P,P) is on topic
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and Pn(Pn) is a strawman error intentionally designed to deceive.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If _Infinite_Loop, which isn't at all related to P is on topic, then Pn,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> which is one of the P's you talk about must be.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I get to decide what is on topic and what is off topic, I own the topic.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Remember, you confusingly talk about a CLASS of H's since the H you keep
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on mentioning doesn't have a distinct rule (since if changes how much is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates to be every possible length of simulation), thus giving them
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> distinct names is a reasonable thing to do.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I am referring to one machine language immutable literal string named H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and another immutable machine language literal string named P.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then we'll refer to H as Ha and refer to P as Pa.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No we will not.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We all know exactly why not. Because by being clear about which H and which P we're talking about, it exposes the holes in your argument and makes it clear exactly where the problem is. So as Ben has said, clarity is your enemy.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So explain exactly what is wrong with the below statement. Failure to explain in detail why it is wrong in your next post will be taken as not being able to explain why it is wrong and an acceptance that it is correct. Stating "strawman" without an explanation will be taken as a failure to explain.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulating the input to Ha(Pa,Pa) up to an infinite number of steps is done by UTM(Pa,Pa) which halts, so Ha(Pa,Pa)==0 is wrong. And Hb(Pa,Pa)==1 which also shows that Ha(Pa,Pa)==0 is wrong. And yes the input to Ha(Pa,Pa) is the same as the input to Hb(Pa,Pa), and you have no basis to claim otherwise.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is just like you are saying that because the dog named Spot is black
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and the cat named Fluffy is white therefore the dog named Rover cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be brown.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ha(Pa,Pa)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hb(Pa,Pa)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulate(Pa,Pa)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are computationally distinct at the x86 machine language level
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and you have always known this therefore you are a damned liar.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I know that you *claim* they are distinct, but you have nothing to back that up. Both Ha and Hb are halt deciders and both are given the same exact input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P does not call anything besides H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And because the fixed algorithm of H aborts, then H is the same as Ha and P is therefore the same as Pa.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> How dishonest can you get?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is the same as if you claimed that 5 == 6
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because they have entirely different execution traces
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> They're identical up to the point that Ha aborts,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> They are not identical therefore it is either ridiculously stupid to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> claim that they should have the same behavior or in your case (because
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> we know that you are not stupid) it would be dishonest.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If Ha(Pa,Pa) and Hb(Pa,Pa) are not identical because as you claim the traces differ, then that would also mean that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since you always knew this: that you are a liar when
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you claimed that they are equivalent.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I know that you *claim* they are distinct, but you have nothing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to back that up.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I don't think that we are getting anywhere.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Translation: You can't explain why I'm wrong and you're backed into a corner.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All of the recent discussions are simply disagreement with an easily
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> verifiable fact. Any smart software engineer with a sufficient technical
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> background can easily confirm that H(P,P)==0 is correct:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is an easily verified fact that Ha(Pa,Pa)==0 is NOT correct > as Hb(Pa,Pa)==1 demonstrates that Ha aborted too soon. By the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of the problem any H is required to map the halting function,
>>>>>>>>>>>>>>>>>>>>>>>>>>>> which means the correct answer for Ha(Pa,Pa) and Hb(Pa,Pa) is 1 because
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Pa(Pa) halts. Any claim that Ha(Pa,Pa) and Hb(Pa,Pa) are not deciding
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same thing is baseless.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> A software engineer with sufficient technical competence would disagree.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> So no explanation why this is wrong, just a baseless claim.
>>>>>>>>>>>>>>>>>>>>>>>>>> In other words you are ignoring my explanation and making up the Jackass
>>>>>>>>>>>>>>>>>>>>>>>>>> lie that I never explained it.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> And you seem to forget that I shot that down (see below)
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/23/2022 9:32 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/23/2022 9:23 PM, Dennis Bush wrote:>> So explain exactly what is
>>>>>>>>>>>>>>>>>>>>>>>>>> wrong with the below statement. >>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulating the input to Ha(Pa,Pa) up to an infinite number of steps is
>>>>>>>>>>>>>>>>>>>>>>>>>>>> done by UTM(Pa,Pa) which halts, so Ha(Pa,Pa)==0 is wrong. And
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Hb(Pa,Pa)==1 which also shows that Ha(Pa,Pa)==0 is wrong. And yes the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to Ha(Pa,Pa) is the same as the input to Hb(Pa,Pa), and you have
>>>>>>>>>>>>>>>>>>>>>>>>>>>> no basis to claim otherwise.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> It is just like you are saying that because the dog named Spot is black
>>>>>>>>>>>>>>>>>>>>>>>>>>> and the cat named Fluffy is white therefore the dog named Rover cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>> be brown.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Ha(Pa,Pa)
>>>>>>>>>>>>>>>>>>>>>>>>>>> Hb(Pa,Pa)
>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulate(Pa,Pa)
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> are computationally distinct at the x86 machine language level
>>>>>>>>>>>>>>>>>>>>>>>>>>> and you have always known this therefore you are a damned liar.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> As I stated previously which you dishonestly clipped:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> I know that you *claim* they are distinct, but you have nothing to back that up.
>>>>>>>>>>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>>>>>>>>>>> [00001352](01) 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>> [00001353](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>> [00001358](01) 50 push eax // push P
>>>>>>>>>>>>>>>>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>> [0000135c](01) 51 push ecx // push P
>>>>>>>>>>>>>>>>>>>>>>>> [0000135d](05) e840feffff call 000011a2 // call H
>>>>>>>>>>>>>>>>>>>>>>>> [00001362](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>>>>>>>>>> [00001365](02) 85c0 test eax,eax
>>>>>>>>>>>>>>>>>>>>>>>> [00001367](02) 7402 jz 0000136b
>>>>>>>>>>>>>>>>>>>>>>>> [00001369](02) ebfe jmp 00001369
>>>>>>>>>>>>>>>>>>>>>>>> [0000136b](01) 5d pop ebp
>>>>>>>>>>>>>>>>>>>>>>>> [0000136c](01) c3 ret
>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> It is self-evident that the simulated input to H1(P,P) has a different
>>>>>>>>>>>>>>>>>>>>>>>> execution trace than the simulated input to H(P,P) because H1 does not
>>>>>>>>>>>>>>>>>>>>>>>> have a pathological self-reference (Olcott 2004) relationship with P.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> It is self evident that the difference in the execution trace of H1(Pa,Pa) an Ha(Pa,Pa) is because Ha aborts too soon.
>>>>>>>>>>>>>>>>>>>>>> Unless H(P,P) aborts the simulation of its input its simulation would
>>>>>>>>>>>>>>>>>>>>>> never stop running. Because you already know this that makes you a liar.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> There is no "unless" because the fixed algorithm of Ha does abort.
>>>>>>>>>>>>>>>>>>>> There are two hypothetically possible definitions of H:
>>>>>>>>>>>>>>>>>>>> (a) H aborts its input at some point.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> i.e. Ha which is called by Pa
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> (b) H that does not abort its input at some point.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> i.e. Hn which is called by Pn
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Because (b) would result in an infinite simulation we know that (a) is
>>>>>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> So in other words, you claim that because Pn(Pn) does not halt, Ha(Pa,Pa)==0 is correct.
>>>>>>>>>>>>>>>>>> No I don't make that claim at all.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You may not realize it, but that's *exactly* what you're saying.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I am saying if X is not an animal then X is not a dog. You are saying
>>>>>>>>>>>>>>>> that if X is not an animal then X might still be a Chi Hua Hua.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> So nothing but a bad analogy. Which means you have no response.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Whether you think so or not, you are making the claim that because Pn(Pn) does not halt, Ha(Pa,Pa)==0 is correct
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> In any case technically competent people that are not liars would agree
>>>>>>>>>>>>>>>> with me.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No one you've spoken to has any reason to lie.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Sure they do animosity and the sadistic pleasure of playing head games.
>>>>>>>>>>>>>> The same motive as any internet troll.
>>>>>>>>>>>>>>>>> Each different H has a different P built from it, and each of those P's are distinct computations, totally unrelated to each other.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Pa has a fixed algorithm which uses Ha and *only* Ha. If you say "what if Ha was changed to be the same as Hn" then you no longer have Ha but instead have Hn, and subsequently you no longer have Pa but instead have Pn.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Read this again (or for the first time, given your attention span) and make sure you understand it, and be prepared to respond to it. Otherwise you're admitting that you don't have a case.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The fact that 5 != 6 proves that 5 == 6 is false.
>>>>>>>>>>>>>> The fact that the correctly simulated input to H(P,P) cannot possibly
>>>>>>>>>>>>>> reach its "ret" instruction proves that H(P,P)==0 is correct.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Ha(Pa,Pa) does not perform a correct simulation as demonstrated by Hb(Pa,Pa) == 1 and by the definition of the correct answer, i.e. Pa(Pa) halts so 1 is correct.
>>>>>>>>>>>> It is the Assembly language source-code of P
>>>>>>>>>>>
>>>>>>>>>>> And the source code of Ha because it is part of the complete program that is Pa. Which also means that Hb(Pa,Pa) and Ha(Pa,Pa) are necessarily deciding on the same thing.
>>>>>>>>>> We can see by the actual correct execution trace that this is false.
>>>>>>>>>>
>>>>>>>>>> Ha(Pa,Pa) is deciding whether or not its input reaches its "ret"
>>>>>>>>>> instruction when Ha has a pathological self-reference (Olcott 2004)
>>>>>>>>>> relationship with P.
>>>>>>>>>>
>>>>>>>>>> is not at all the same as Hb(Pa,Pa) is deciding whether or not its input
>>>>>>>>>> reaches its "ret" instruction when Hb DOES NOT HAVE a pathological
>>>>>>>>>> self-reference (Olcott 2004) relationship with P.
>>>>>>>>>
>>>>>>>>> By definition they are the same. Unless you can provide an accepted external reference, there is no exception for self reference.
>>>>>>>>>
>>>>>>>>> The difference in the traces is that Ha incorrectly reports non-halting behavior and aborts too soon, while Hb continues to simulate to a final state.
>>>>>>>> I am giving up on you, you are nothing but a God damned liar.
>>>>>>>
>>>>>>> I'm telling you the truth that you don't want to hear.
>>>>>> You know that any fully competent software engineer can easily determine
>>>>>> that the correct x86 emulation of the input to H(P,P)
>>>>>
>>>>> Is performed by Hb(Pa,Pa) which shows that a final state is reached and proves that Ha(Pa,Pa)==0 is wrong.
>>>> No this merely yet again proves that you are a lying cheating bastard.
>>>> I am referring to H at machine address 000011a2. Since Hb is not at
>>>> machine address 000011a2 and you know it this proves that you are a
>>>> lying cheating bastard.
>>>
>>> It doesn't matter what address Hb and Ha are at. What matters is that there's no exception for self reference and you know it.
>> For the time being I am only referring to when the C function named H
>> determines whether or not its correct x86 emulation
>
> Which has not been established

Liar Liar pants on fire.

_P()
[00001352](01) 55 push ebp
[00001353](02) 8bec mov ebp,esp
[00001355](03) 8b4508 mov eax,[ebp+08]
[00001358](01) 50 push eax // push P
[00001359](03) 8b4d08 mov ecx,[ebp+08]
[0000135c](01) 51 push ecx // push P
[0000135d](05) e840feffff call 000011a2 // call H
[00001362](03) 83c408 add esp,+08
[00001365](02) 85c0 test eax,eax
[00001367](02) 7402 jz 0000136b
[00001369](02) ebfe jmp 00001369
[0000136b](01) 5d pop ebp
[0000136c](01) c3 ret
Size in bytes:(0027) [0000136c]

In software engineering terms: H(P,P) correctly determines that its
correctly emulated input never reaches its "ret" instruction.

--
Copyright 2022 Pete Olcott

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