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.

So you are just caught in the lie.

You claim to be showing an repeating infinite loop, but it is OBVIOUS
that when P(P) calls H(P,P) that it will very quickly get an answer
backm and NOT the infinite lopp you claim it gets stuck in.

The fact that you H doesn't even look into the behavior of H is a sign
that it can easily be wrong. The fact that its prediction doesn't match
what it actaully does, proves it.

You need to LIE about the pattern that it produces, because the accurate
trace is so short it is easy to see the flaw.

You had to shorten the trace that it actually did, because making it
behave as you show above made you H needing to use static memory to
comunicate between layers, show that you weren't a pure function.

And the rest is NOT a change of subject, but point out that you are not
correct about H exactly correctly simulating its input.

Since you LIE, your words are not correct.

YOU FAIL.