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

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.

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:

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
>

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.

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

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

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

On 8/15/22 11:02 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.
>>
>
> So you agree that if this is the correct measure of the behavior of the
> input then H(P,P)==0 is correct?
>
>

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

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,

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,