On Wed, 17 Aug 2022 13:05:33 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/17/2022 12:53 PM, Mr Flibble wrote:
> > 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.
>
> My key unique discovery (back in 2016) was that every conventional
> "pathological" input used to prove that the HP cannot be solved
> specifies infinitely recursive simulation to every simulating halt
> decider.

WRONG YOU OBTUSE FUCKING FUCKTARD. I HAVE DESIGNED A SIMULATING HALT
DECIDER THAT IS NOT INFINITELY RECURSIVE. HOW MANY MORE TIMES DO I HAVE
TO TELL YOU THIS BEFORE IT SINKS IN?

/FLIBBLE