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.

--
Copyright 2022 Pete Olcott

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