On Wed, 17 Aug 2022 12:44:17 -0500
olcott <NoOne@NoWhere.com> wrote:

> 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.

FALSE. P is NOT recursive, your H is recursive, this is plainly obvious
to everyone except you.

Why do you persist in attempting to waste everyone's time?

/Flibble