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.

It is just wrong, and you prove you are dumb. You start from a LIE, so
you can't actualy prove what you claim.

The ACTUAL CORRECT and COMPLETE simulation of the input to H(P,P), which
P does not do, will Halt, so H(P,P) returning 0 is incorrect.

You are just showing that you are living in a fantasy world where Truth
doesn't actualy matter.

You are just talking about POOP, not Halting.