On 8/17/2022 1:35 PM, Mr Flibble wrote:
> On Wed, 17 Aug 2022 13:29:36 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 8/17/2022 1:21 PM, Mr Flibble wrote:
>>> On Wed, 17 Aug 2022 13:13:32 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 8/17/2022 1:09 PM, Mr Flibble wrote:
>>>>> 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
>>>>>
>>>>
>>>> Yet the behavior of your "simulation" of its
>>>> input is incorrect in that it does not correspond
>>>> to the beahavior that P actually specifies.
>>>>
>>>> P does not specify that its simulation is supposed
>>>> to be forked off into two different processes.
>>>
>>> P doesn't "have a simulation", a crucial point you keep missing, P
>>> doesn't care what kind of decider H is. Also my SHD does not fork
>>> off into "two different processes", the *simulation* is forked and
>>> P is totally unaware that that has happened, which IMO is a
>>> perfectly legit, original approach to the problem.
>>>
>>> /Flibble
>>>
>>
>> Yet you cannot even specify the code for the "if statement" that
>> determines that it should do this.
>>
>> if (some how some way the halt decider determines that its input
>> halts) report halting
>> else if (some how some way the halt decider determines that its input
>> does not halt)
>> report non-halting
>> else
>> report pathological input
>
> I only need to specify code if I was to actually implement it.

What you have done is the same as if I said:
"I have a cure for cancer" where my "cure" is:
(1) Find a cure for cancer
(2) Then we have a cure for cancer.

> Implementing a simulating halt decider is not particularly hard:
> detecting halting is trivial and detecting non-halting is done by
> detecting duplication of the finite machine state

Which is the most important part and you did not
even do this in the simplest possible case:

void Infinite_Loop()
{ HERE: goto HERE;
}

_Infinite_Loop()
[00001102](01) 55 push ebp
[00001103](02) 8bec mov ebp,esp
[00001105](02) ebfe jmp 00001105
[00001107](01) 5d pop ebp
[00001108](01) c3 ret
Size in bytes:(0007) [00001108]

> which may or may not
> happen within the lifetime of the observable universe.
>
> /Flibble
>

--
Copyright 2022 Pete Olcott

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