On 8/17/2022 12:41 PM, Mr Flibble wrote:
> On Wed, 17 Aug 2022 12:37:19 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 8/17/2022 12:16 PM, Mr Flibble wrote:
>>> On Wed, 17 Aug 2022 12:09:59 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 8/17/2022 11:57 AM, Dennis Bush wrote:
>>>>> On Wednesday, August 17, 2022 at 12:55:38 PM UTC-4, olcott wrote:
>>>>>
>>>>>> On 8/17/2022 11:25 AM, Dennis Bush wrote:
>>>>>>> On Wednesday, August 17, 2022 at 12:19:51 PM UTC-4, olcott
>>>>>>> wrote:
>>>>>>>> On 8/17/2022 11:06 AM, Dennis Bush wrote:
>>>>>>>>> On Wednesday, August 17, 2022 at 11:55:36 AM UTC-4, olcott
>>>>>>>>> wrote:
>>>>>>>>>> On 8/17/2022 10:35 AM, Dennis Bush wrote:
>>>>>>>>>>> On Wednesday, August 17, 2022 at 11:24:34 AM UTC-4, olcott
>>>>>>>>>>> wrote:
>>>>>>>>>>>> On 8/17/2022 9:51 AM, Dennis Bush wrote:
>>>>>>>>>>>>> On Wednesday, August 17, 2022 at 10:23:17 AM UTC-4, olcott
>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>> On 8/17/2022 6:40 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Wednesday, August 17, 2022 at 12:28:52 AM UTC-4,
>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>> On 8/16/2022 11:02 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:57:51 PM UTC-4,
>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>> On 8/16/2022 10:53 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:39:32 PM UTC-4,
>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 8/16/2022 10:23 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:18:46 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 9:52 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 10:47:57 PM
>>>>>>>>>>>>>>>>>>>>>>> UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 9:34 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 10:12:55 PM
>>>>>>>>>>>>>>>>>>>>>>>>> UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 8:55 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/22 9:20 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 8:10 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/22 10:27 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 9:07 AM, Skep Dick wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, 16 August 2022 at 15:55:30
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+2, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete x86 emulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the input to H(P,P) by H WOULD
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never stop running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Sounds like you are stuck in a loop.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Maybe your Decider/Maker should
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate you.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have been trying to get an honest
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> person to acknowledge the correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> software engineering of my system so
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that we can move on to the next point
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for a year now. (bot many honest people
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> here, mostly trolls).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The problem is that what you say ISN'T
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> CORRECT software engineering.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You use the wrong definition of things and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect assumptions about thing, so it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just isn't true.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) does correctly predict that its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete x86 emulation of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input would never stop running, thus does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly reject this input as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope. And in fact, you even acknoldge it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't but just don't see it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you are saying that the correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete x86 emulation by H(P,P) of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>> input WOULD STOP RUNNING?
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> No, I am saying that you H doesn't do a
>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete emulation of its input,
>>>>>>>>>>>>>>>>>>>>>>>>>>> and thus to say it did is just a LIE.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> I said that H correctly predicts what the
>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of its correct and complete x86
>>>>>>>>>>>>>>>>>>>>>>>>>> emulation of H(P,P) would be
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The fixed source code of H (and everything it
>>>>>>>>>>>>>>>>>>>>>>>>> calls) that aborts is Ha. Ha *always* aborts
>>>>>>>>>>>>>>>>>>>>>>>>> Pa, so "the correct and complete simulation of
>>>>>>>>>>>>>>>>>>>>>>>>> Ha(Pa,Pa)" does not exist, just like the shoes
>>>>>>>>>>>>>>>>>>>>>>>>> that Napoleon wore on Mars do not exist.
>>>>>>>>>>>>>>>>>>>>>>>> So you are another brain dead moron the
>>>>>>>>>>>>>>>>>>>>>>>> believes it is utterly impossible for H to
>>>>>>>>>>>>>>>>>>>>>>>> correctly predict that its correct and
>>>>>>>>>>>>>>>>>>>>>>>> complete x86 emulation of its input would
>>>>>>>>>>>>>>>>>>>>>>>> never stop running unless H actually performed
>>>>>>>>>>>>>>>>>>>>>>>> a correct and complete emulation of its input.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The correct and complete emulation of Ha(Pa,Pa)
>>>>>>>>>>>>>>>>>>>>>>> doesn't exist,
>>>>>>>>>>>>>>>>>>>>>> Neither does the correct and complete emulation
>>>>>>>>>>>>>>>>>>>>>> of Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Yes it does. If you simulate Infinite_Loop(), it
>>>>>>>>>>>>>>>>>>>>> won't halt. But if you run Ha(Pa,Pa), it won't do
>>>>>>>>>>>>>>>>>>>>> a correct and complete simulation because it
>>>>>>>>>>>>>>>>>>>>> aborts.
>>>>>>>>>>>>>>>>>>>> When you run H0((u32)Infinite_Loop)
>>>>>>>>>>>>>>>>>>>> "it won't do a correct and complete simulation
>>>>>>>>>>>>>>>>>>>> because it aborts" How long are you going to keep
>>>>>>>>>>>>>>>>>>>> the head game up?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> That you don't understand what I'm saying doesn't
>>>>>>>>>>>>>>>>>>> make it a head game.
>>>>>>>>>>>>>>>>>> You reject Ha(Pa,Pa) on this basis
>>>>>>>>>>>>>>>>>> run Ha(Pa,Pa), it won't do a correct and complete
>>>>>>>>>>>>>>>>>> simulation because it aborts.
>>>>>>>>>>>>>>>>>> Yet accept P0(Infinite_Loop), on the same basis
>>>>>>>>>>>>>>>>>> it won't do a correct and complete simulation because
>>>>>>>>>>>>>>>>>> it aborts. ∴ You are playing head games.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> What does P0 do? Does it abort? If so, then yes
>>>>>>>>>>>>>>>>> P0(Infinite_Loop) doesn't do a correct and complete
>>>>>>>>>>>>>>>>> simulation because it aborts, so it's invalid to
>>>>>>>>>>>>>>>>> predict what the correct and complete simulation of
>>>>>>>>>>>>>>>>> P0(Infinite_Loop) would do.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On the other hand, UTM(Infinite_Loop) does do a
>>>>>>>>>>>>>>>>> correct and complete simulation, so it *is* valid to
>>>>>>>>>>>>>>>>> predict what it will do.
>>>>>>>>>>>>>>>> In other words you are not bright enough to see that it
>>>>>>>>>>>>>>>> is very easy for H0 to recognize an infinite loop would
>>>>>>>>>>>>>>>> never halt in a finite number of steps of simulation?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I'm saying that H0 can see that the correct and complete
>>>>>>>>>>>>>>> simulation performed by UTM(Infinite_Loop) does not
>>>>>>>>>>>>>>> halt. It does not and cannot see that the correct and
>>>>>>>>>>>>>>> complete simulation performed by H0(Infinite_Loop)
>>>>>>>>>>>>>>> (i.e. your basis for correctness) does not halt because
>>>>>>>>>>>>>>> H0 does not perform a correct and complete simulation.
>>>>>>>>>>>>>> This is what I mean by H evaluating what its correct and
>>>>>>>>>>>>>> complete simulation of its input would be:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> int Halt_Status = Simulate(x, x);
>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Although H itself does not perform a correct and complete
>>>>>>>>>>>>>> simulation of non-halting inputs H does correctly predict
>>>>>>>>>>>>>> that such a simulation would never halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You changed the input from Pa to Pn.
>>>>>>>>>>>>>
>>>>>>>>>>>>> So you're again saying that Ha(Pa,Pa) reports the halt
>>>>>>>>>>>>> status of the non-input Pn(Pn) instead of Pa(Pa) as it is
>>>>>>>>>>>>> required to:
>>>>>>>>>>>> H0(Infinite_Loop)
>>>>>>>>>>>> reports on Simulate(Infinite_Loop)
>>>>>>>>>>>>
>>>>>>>>>>>> H(Infinite_Recursion, 0x777)
>>>>>>>>>>>> reports on Simulate((Infinite_Recursion, 0x777)
>>>>>>>>>>>>
>>>>>>>>>>>> In every case a simulating halt decider reports on what the
>>>>>>>>>>>> behavior of its simulated input would be if this SHD was
>>>>>>>>>>>> swapped for a simulator.
>>>>>>>>>>>
>>>>>>>>>>> And in the case of Ha(Pa,Pa) you change the input in doing
>>>>>>>>>>> so which is not allowed. Remember, what is being decided on
>>>>>>>>>>> is the FIXED source code of Pa and everything it calls,
>>>>>>>>>>> which includes the FIXED source code of Ha and everything
>>>>>>>>>>> it calls.
>>>>>>>>>> THIS JUST SEEMS OVER YOUR HEAD.
>>>>>>>>>> H correctly determines that its input would never halt by
>>>>>>>>>> correctly predicting that its input would never halt if H
>>>>>>>>>> never aborted its simulation of this input.
>>>>>>>>>
>>>>>>>>> Which is not what it is required to do if it claims to be a
>>>>>>>>> halt decider:
>>>>>>>>>
>>>>>>>>> For *any* algorithm X and input Y:
>>>>>>>>> H(X,Y)==1 if and only if X(Y) halts, and
>>>>>>>>> H(X,Y)==0 if and only if X(Y) does not halt
>>>>>>>>>
>>>>>>>> This is based on the false assumption that the actual behavior
>>>>>>>> of the actual input is the same behavior as X(Y).
>>>>>>>
>>>>>>> FALSE, because it is the behavior of the direct execution that
>>>>>>> is being asked about.
>>>>>> So you disagree that every decider must base its decision on a
>>>>>> semantic or syntactic property of its input?
>>>>>>
>>>>>> In other words you are asserting that a decider must base its
>>>>>> decision on a semantic or syntactic property of a non-input?
>>>>>
>>>>> You're the one asserting that, as you think that Ha(Pa,Pa) should
>>>>> be reporting the halt status of Pn(Pn):
>>>>
>>>> H is reporting on the behavior that these machine language bytes
>>>> specify:
>>>> 558bec518b4508508b4d0851e8bffeffff83c4088945fc837dfc007402ebfe8be55dc3
>>>>
>>>> _P()
>>>> [00000fc2](01) 55 push ebp
>>>> [00000fc3](02) 8bec mov ebp,esp
>>>> [00000fc5](01) 51 push ecx
>>>> [00000fc6](03) 8b4508 mov eax,[ebp+08]
>>>> [00000fc9](01) 50 push eax
>>>> [00000fca](03) 8b4d08 mov ecx,[ebp+08]
>>>> [00000fcd](01) 51 push ecx
>>>> [00000fce](05) e8bffeffff call 00000e92
>>>> [00000fd3](03) 83c408 add esp,+08
>>>> [00000fd6](03) 8945fc mov [ebp-04],eax
>>>> [00000fd9](04) 837dfc00 cmp dword [ebp-04],+00
>>>> [00000fdd](02) 7402 jz 00000fe1
>>>> [00000fdf](02) ebfe jmp 00000fdf
>>>> [00000fe1](02) 8be5 mov esp,ebp
>>>> [00000fe3](01) 5d pop ebp
>>>> [00000fe4](01) c3 ret
>>>> Size in bytes:(0035) [00000fe4]
>>>
>>> No it isn't, as you "abort the simulation" so it never reaches
>>> 00000fd3.
>>>
>>> /Flibble
>>>
>>
>> Even though you claim to be a computer scientist you have proven that
>> you do not sufficiently understand the idea of unreachable code in
>> that the correctly simulated input to H(P,P) can never reach past
>> [00000fca] whether its simulation has been aborted or not.
>>
>> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
>> (b) that simulates P(P) that calls a simulated H(P,P)
>> (c) that simulates P(P) that calls a simulated H(P,P)
>> (d) that simulates P(P) that calls a simulated H(P,P)...
>> *Until H aborts its simulation*
>
> You are either deluded or a liar, which is it? I am a computer
> scientist and I have pointed out your mistakes over and over again
> including in the reply in this thread. The code is only "unreachable"
> because you abort the simulation as you couldn't come up with a
> solution that avoids infinite recursion (like I did).
>
> /Flibble
>

The reason that I moved this discussion to comp.lang.c and
comp.lang.c++ is that the people there would be able to see that you are
incorrect about this. Many of the people here only understand the
abstract theory of computer science and have essentially no knowledge of
the actual behavior of real world programs.

--
Copyright 2022 Pete Olcott

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