On 8/17/2022 12:35 PM, Mr Flibble wrote:
> On Wed, 17 Aug 2022 12:30:38 -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):
>> A simulating halt decider always reports on what the behavior of its
>> pure simulation of its input would be on the basis of recognizing an
>> infinite behavior pattern that correctly predicts what the behavior
>> of this pure simulation would be without the need to actually perform
>> this pure simulation.
>
> Not when the infinite behaviour is a property of the decider itself as

It superficially seems like the behavior of H(P,P) is mutual infinite
recursion until you realize the H is merely mimicking the behavior that
P specifies.

--
Copyright 2022 Pete Olcott

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