On 8/16/2022 8:20 PM, Richard Damon wrote:
>
> On 8/16/22 9:44 AM, olcott wrote:
>> On 8/16/2022 6:16 AM, Richard Damon wrote:
>>> On 8/15/22 11:28 PM, olcott wrote:
>>>> On 8/15/2022 9:51 PM, Richard Damon wrote:
>>>>> On 8/15/22 10:40 PM, olcott wrote:
>>>>>> On 8/15/2022 9:20 PM, Richard Damon wrote:
>>>>>>> On 8/15/22 9:58 PM, olcott wrote:
>>>>>>>> On 8/15/2022 8:47 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 8/15/22 9:16 PM, olcott wrote:
>>>>>>>>>> On 8/15/2022 8:04 PM, Richard Damon wrote:
>>>>>>>>>>> On 8/15/22 8:43 PM, olcott wrote:
>>>>>>>>>>>> On 8/15/2022 7:33 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 8/15/22 7:36 PM, olcott wrote:
>>>>>>>>>>>>>> On 8/15/2022 5:47 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 8/15/22 10:56 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 8/15/2022 6:50 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 8/14/22 10:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 8/14/2022 9:14 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 8/14/22 9:58 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 8/14/2022 8:52 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 8/14/22 9:41 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 8/14/2022 8:30 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 8/14/22 9:08 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 8/14/2022 7:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 8/14/22 7:33 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/14/2022 6:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/14/22 6:58 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/14/2022 5:16 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/14/22 5:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Mr Flibble <flibble@reddwarf.jmc.corp>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Wrote in message:r
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sun, 14 Aug 2022 14:18:53 -0500olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <NoOne@NoWhere.com> wrote:> On 8/14/2022
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 2:14 PM, Mr Flibble wrote:> > On Sun, 14
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Aug 2022 10:14:28 -0500> > olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <NoOne@NoWhere.com> wrote:> >   > >>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is refers to H(P,P)==0 where H and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P are functions in C*> >>> >> I believe I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have learned something valuable from
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you:> >> that by simulation, and by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulations within simulations,> >>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting can sometimes be detected,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and in particular,> >> it can be detected
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in the program used in the classical> >>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proof of incomputability.> >>> >>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Halting problem proofs refuted on the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> basis of software> >> engineering* ?> >>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>  > > > > I am also a computer
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> scientist and I am telling you that your>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> > halting decider reporting non-halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when it enters "infinite> > recursion" is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an ERROR.  There is no infinite recursion
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in the HP> > proofs you are attempting to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> refute.> > > > /Flibble> > > > > void
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P(ptr x)> {> int Halt_Status = H(x, x);>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)>      HERE: goto HERE;>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return;> }> > int main()> {>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));> }> >
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If it was true that you are a computer
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> scientist then you would > understand
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that this execution trace is correct:> >
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (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*I am a computer
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> scientist and all your trace shows is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H (not P) isat the root of your so
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> called "infinite recursion" and is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> primaryreason why you are incorrect to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> map this recursive behaviour of your Hto
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a halting decision on P of non-halting.>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> > If you do not understand that the above
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution trace is correct> then this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proves that you are not as much as a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sufficiently competent > software
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> engineer.It seems I understand your trace
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> more than you do which makes itobvious
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> who is actually lacking in competence
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> here./Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because H exactly simulates its input and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> has no control flow
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>   behavior of it's own while it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating this input YOU ARE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>   BLAMING THE MIRROR FOR WHAT IT REFLECTS.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H does have control low on its own, or it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can't stop the simulationg to give an answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Because H exactly simulates its input and
>>>>>>>>>>>>>>>>>>>>>>>>>>>> has no control flow
>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of it's own
>>>>>>>>>>>>>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>>>>>>>>>>>>>> while it is simulating this input
>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU ARE BLAMING THE MIRROR FOR WHAT IT
>>>>>>>>>>>>>>>>>>>>>>>>>>>> REFLECTS.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So either you are a liar, or just badly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> confused about what you are saying.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Or you OCD prevents you from paying close
>>>>>>>>>>>>>>>>>>>>>>>>>>>> enough attention to ALL of my words.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Then how does it decide to stop simulating if
>>>>>>>>>>>>>>>>>>>>>>>>>>> it has no control flow before it stops?
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> H does not have any effect on the behavior of
>>>>>>>>>>>>>>>>>>>>>>>>>> its simulated P the whole time that H is
>>>>>>>>>>>>>>>>>>>>>>>>>> simulating P, thus any recursive behavior that
>>>>>>>>>>>>>>>>>>>>>>>>>> P demonstrates is behavior of P and not
>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of H.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Nope, the problem is in H, not P.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> This H by its actions might not affect the
>>>>>>>>>>>>>>>>>>>>>>>>> behavior of the input it is simulating, but it
>>>>>>>>>>>>>>>>>>>>>>>>> doesn't correctly determine the effect that the
>>>>>>>>>>>>>>>>>>>>>>>>> copy of H in P will have.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>    return;
>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>    Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> So you disagree with this:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> (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*
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> That isn't what your H does,
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Why do you say that isn't what my H does when you
>>>>>>>>>>>>>>>>>>>>>> know that it is what my H does and you can verify
>>>>>>>>>>>>>>>>>>>>>> this with the complete system?
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> https://www.liarparadox.org/2022_07_22.zip
>>>>>>>>>>>>>>>>>>>>>> This is the complete system that compiles under:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Microsoft Visual Studio Community 2017
>>>>>>>>>>>>>>>>>>>>>> https://visualstudio.microsoft.com/vs/older-downloads/
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Right, you didn't read what I said you H does, did
>>>>>>>>>>>>>>>>>>>>> you?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You said that what I said H does, it does not do,
>>>>>>>>>>>>>>>>>>>> this is incorrect.
>>>>>>>>>>>>>>>>>>>> Then you changed the subject.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You H does NOT get to the step (b) that you have
>>>>>>>>>>>>>>>>>>> posted, so doesn't match you pattern.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> One H does not get past step (b)
>>>>>>>>>>>>>>>>>> The other H does not get past step (c) and can be
>>>>>>>>>>>>>>>>>> adapted to proceed any finite number of steps.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The point is that no correct simulation of the input
>>>>>>>>>>>>>>>>>> to H(P,P) by H ever stops running until H aborts it.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Nope, look at the code you provided.
>>>>>>>>>>>>>>>> Liar
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Are you saying the code you provided DOESN'T abort the
>>>>>>>>>>>>>>> simulation done by H(P,P) at the point where P(P) calls
>>>>>>>>>>>>>>> H(P,P)?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The algorithm implemented by H:
>>>>>>>>>>>>>> The correct simulation by H(P,P), never stops running
>>>>>>>>>>>>>> until H aborts it.
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, the algorithm implemented by your H is to abort the
>>>>>>>>>>>>> simulation of P(P) as soon as it calls H(P,P).
>>>>>>>>>>>> So you don't know the difference between an algorithm and
>>>>>>>>>>>> its implementation?
>>>>>>>>>>>>
>>>>>>>>>>>> https://www.geeksforgeeks.org/introduction-to-algorithms/
>>>>>>>>>>>>
>>>>>>>>>>>> The algorithm: A simulating halt decider (SHD) continues to
>>>>>>>>>>>> simulate its input until it correctly matches a non-halting
>>>>>>>>>>>> behavior pattern or the input halts on its own. If a
>>>>>>>>>>>> non-halting behavior pattern is matched then the SHD aborts
>>>>>>>>>>>> the simulation of its input and reports non-halting. If the
>>>>>>>>>>>> input halts on its own the SHD report halting.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Right. But, to be an algorithm, you need to SPECIFY the list
>>>>>>>>>>> of non-halting behavior patterns, not just say it "match one"
>>>>>>>>>>> without providing them,
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Then call it a high level design.
>>>>>>>>>>
>>>>>>>>>>> Note, from the page you mention:
>>>>>>>>>>> Finite-ness: The algorithm must be finite, i.e. it should
>>>>>>>>>>> terminate after a finite time.
>>>>>>>>>>>
>>>>>>>>>>> "Proving a pattern is non-halting" is not a finite algorithm.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> My detailed design only needs to apply to this pattern:
>>>>>>>>>>     For any program H that might determine if programs halt, a
>>>>>>>>>>     "pathological" program P, called with some input, can pass
>>>>>>>>>>     its own source and its input to H and then specifically do
>>>>>>>>>> the
>>>>>>>>>>     opposite of what H predicts P will do.
>>>>>>>>>>     *No H can exist that handles this case*
>>>>>>>>>>     https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>>>>
>>>>>>>>>>> "Proving" something is not an algorithmic step, as there is
>>>>>>>>>>> no guarantee that something CAN be proved in finite time.
>>>>>>>>>>
>>>>>>>>>> I have proved that it can be proved in the above example.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> That is just the assuming a Halt Decider exists fallacy.
>>>>>>>>>>>
>>>>>>>>>>> The pattern you CLAIM, is proved to not be correct, so your
>>>>>>>>>>> specific implementation is incorrect.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I prove that the input does not halt, it is no rebuttal at all
>>>>>>>>>> (and ridiculously stupid) to say that my system does not work
>>>>>>>>>> on a non-input.
>>>>>>>>>>
>>>>>>>>>>> Obviously, you still don't understand what an algorithm is.
>>>>>>>>>>>  > Remember, the concept of an algorithm is that it is
>>>>>>>>>>> detailed enough that
>>>>>>>>>>> a simple program could just code based on the description (or
>>>>>>>>>>> someone could just execute it by following it).
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Call it a high level design.
>>>>>>>>>
>>>>>>>>> But it thus isn't an algorithm, so you need to specify it
>>>>>>>>> tighter to call it one
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>> Without an actual list of patterns, it can't just be followed.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> (a) Infinite loop
>>>>>>>>>> (b) infinite recursion
>>>>>>>>>> (c) infinitely recursive simulation either as an adaption to (b)
>>>>>>>>>> or exactly the same as (b).
>>>>>>>>>
>>>>>>>>> Doesn't define what to look for, so not actually a list of
>>>>>>>>> patterns.
>>>>>>>> THIS IS SUFFICIENT FOR EVERY EXCEPTIONALLY TALENTED SOFTWARE
>>>>>>>> ENGINEER TO IMPLEMENT A SHD THAT CORRECTLY DETERMINES THE HALT
>>>>>>>> STATUS OF THE ABOVE PATHOLOGICAL INPUT:
>>>>>>>>
>>>>>>>> The algorithm: A simulating halt decider (SHD) continues to
>>>>>>>> simulate its input until it correctly matches a non-halting
>>>>>>>> behavior pattern or the input halts on its own. If a non-halting
>>>>>>>> behavior pattern is matched then the SHD aborts the simulation
>>>>>>>> of its input and reports non-halting. If the input halts on its
>>>>>>>> own the SHD report halting.
>>>>>>>>
>>>>>>>> INSSTEAD OF PLAYING HEAD GAMES LET'S JUST AGREE ON THAT
>>>>>>>>
>>>>>>>
>>>>>>> Then why does it get the wrong answer?
>>>>>>>
>>>>>> When the measure of the behavior of the input to H(P,P) is the
>>>>>> behavior of the correct simulation that H performs on P THEN H
>>>>>> GETS THE CORRECT ANSWER. H DOES CORRECTLY PREDICT THAT ITS
>>>>>> COMPLETE SIMULATION OF P WOULD NEVER STOP RUNNING.
>>>>>>
>>>>>
>>>>> Except it isn't, so you can't.
>>>>>
>>>>
>>>> The C function H(P,P) does correctly predict that its correct and
>>>> complete x86 emulation of its input would never stop running unless
>>>> and until it aborts its x86 emulation of this input.
>>>>
>>>>
>>>>
>>>
>>> No, it doesn't.
>>>
>>> The Correct and Complete x86 emulation of the program P(P) Halts,
>>
>> Again you lie. The correct and complete x86 emulation of the input to
>> H(P,P) by H never stops running.
>>
>>
>
> The problem is that your H (at least those that answer) don't do a
> complete and correct x86 emultion of their input, so your statement is
> vacuous and unsound.
>
correctly predict
correctly predict
correctly predict
correctly predict
correctly predict
correctly predict
correctly predict
correctly predict

--
Copyright 2022 Pete Olcott

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