On 8/16/2022 11:51 AM, Mr Flibble wrote:
> On Tue, 16 Aug 2022 11:40:56 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 8/16/2022 11:30 AM, Skep Dick wrote:
>>> On Tuesday, 16 August 2022 at 18:21:52 UTC+2, olcott wrote:
>>>> On 8/16/2022 10:16 AM, Skep Dick wrote:
>>>>> On Tuesday, 16 August 2022 at 17:05:05 UTC+2, olcott wrote:
>>>>>> On 8/16/2022 9:53 AM, Skep Dick wrote:
>>>>>>> On Tuesday, 16 August 2022 at 16:37:41 UTC+2, olcott wrote:
>>>>>>>> A computer scientist that has been published in CACM says...
>>>>>>> That's an appeal to authority!
>>>>>>>
>>>>>> Which is legitimate under inductive inference.
>>>>>> When you have cancer you go to an oncologist, not a house
>>>>>> painter.
>>>>> No it isn't!
>>>>>
>>>>> Do you want your onologist to be good at publishing papers.
>>>> You have to actually pay attention to ALL the words that I said
>>> Yes! You fucking retard. Read ALL of MY words.
>>>
>>>> When you have cancer
>>>> When you have cancer
>>>> When you have cancer
>>>> When you have cancer
>>>>
>>>> you go to an oncologist.
>>> WHEN you have cancer do you go to
>>>
>>> An oncologist who THEORISES about oncology (writes papers).
>>> OR
>>> An oncologist who PRACTICES oncology (cures cancer).
>>
>> The point is that when you have cancer you do not go to a
>> hairdresser, you go to an oncologist thus validating the legitimacy
>> of the appeal to authority for inductive rather than deductive
>> reasoning.
>>
>> 1. Appeal to Unqualified Authority (argumentum ad verecundiam):
>> This fallacy is committed whenever someone proposes that some
>> conclusion is true because someone who is NOT an authority on
>> the subject SAID it was true.
>>
>> https://rintintin.colorado.edu/~vancecd/phil1440/weakinduction.pdf
>
> Appeal to authority is ALWAYS a logical fallacy.

Within deductive logical inference.

Within inductive logical inference only the appeal to an unqualified
authority is a fallacy (as I just proved).

>
> /Flibble
>

--
Copyright 2022 Pete Olcott

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

On Tue, 16 Aug 2022 12:03:21 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/16/2022 11:51 AM, Mr Flibble wrote:
> > On Tue, 16 Aug 2022 11:40:56 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 8/16/2022 11:30 AM, Skep Dick wrote:
> >>> On Tuesday, 16 August 2022 at 18:21:52 UTC+2, olcott wrote:
> >>>> On 8/16/2022 10:16 AM, Skep Dick wrote:
> >>>>> On Tuesday, 16 August 2022 at 17:05:05 UTC+2, olcott wrote:
> >>>>>> On 8/16/2022 9:53 AM, Skep Dick wrote:
> >>>>>>> On Tuesday, 16 August 2022 at 16:37:41 UTC+2, olcott wrote:
> >>>>>>>> A computer scientist that has been published in CACM says...
> >>>>>>>>
> >>>>>>> That's an appeal to authority!
> >>>>>>>
> >>>>>> Which is legitimate under inductive inference.
> >>>>>> When you have cancer you go to an oncologist, not a house
> >>>>>> painter.
> >>>>> No it isn't!
> >>>>>
> >>>>> Do you want your onologist to be good at publishing papers.
> >>>> You have to actually pay attention to ALL the words that I said
> >>> Yes! You fucking retard. Read ALL of MY words.
> >>>
> >>>> When you have cancer
> >>>> When you have cancer
> >>>> When you have cancer
> >>>> When you have cancer
> >>>>
> >>>> you go to an oncologist.
> >>> WHEN you have cancer do you go to
> >>>
> >>> An oncologist who THEORISES about oncology (writes papers).
> >>> OR
> >>> An oncologist who PRACTICES oncology (cures cancer).
> >>
> >> The point is that when you have cancer you do not go to a
> >> hairdresser, you go to an oncologist thus validating the legitimacy
> >> of the appeal to authority for inductive rather than deductive
> >> reasoning.
> >>
> >> 1. Appeal to Unqualified Authority (argumentum ad verecundiam):
> >> This fallacy is committed whenever someone proposes that some
> >> conclusion is true because someone who is NOT an authority on
> >> the subject SAID it was true.
> >>
> >> https://rintintin.colorado.edu/~vancecd/phil1440/weakinduction.pdf
> >>
> >
> > Appeal to authority is ALWAYS a logical fallacy.
>
> Within deductive logical inference.
>
> Within inductive logical inference only the appeal to an unqualified
> authority is a fallacy (as I just proved).
>
>
> >
> > /Flibble
> >
>
>

Nope; logical fallacies apply to argument and a logical fallacy is
always a logical fallacy.

/Flibble

On Tuesday, 16 August 2022 at 18:41:03 UTC+2, olcott wrote:
> The point is that when you have cancer you do not go to a hairdresser,
> you go to an oncologist thus validating the legitimacy of the appeal to
> authority for inductive rather than deductive reasoning.
Bullshit! "An oncologist" is not a person. "An oncologist" is a proffession.

There all kinds of oncologists!
There are bad oncologists.
There are good oncologists.
There are experienced oncologists.
There are unexperienced oncologists.
There are poorly qualified oncologists.
There are oncologists which don't keep up with latest developments.
There are oncologists which are on top of their game.
There are oncologists who got into the proffession because they knew people.

> 1. Appeal to Unqualified Authority (argumentum ad verecundiam):
> This fallacy is committed whenever someone proposes that some
> conclusion is true because someone who is NOT an authority on
> the subject SAID it was true.
Yeah! Look at this word ... "UNQUALIFIED".

How do you distinguish between a qualified oncologist from an unqualified oncologist?

Your search procedure is underspecified!

On Tuesday, 16 August 2022 at 19:03:29 UTC+2, olcott wrote:
> Within deductive logical inference.
>
> Within inductive logical inference only the appeal to an unqualified
> authority is a fallacy (as I just proved).
You have failed to prove that the authority you are appealing to is qualified.

Having qualifications is NOT the same thing as being qualified.

On Tuesday, 16 August 2022 at 19:18:35 UTC+2, Mr Flibble wrote:
> Nope; logical fallacies apply to argument and a logical fallacy is
> always a logical fallacy.
You are committing the fallacy fallacy!

Just because the argument is fallacious; or and the reasoning is incorrect it doesn't mean the conclusion is wrong.

On 8/16/2022 12:21 PM, Skep Dick wrote:
> On Tuesday, 16 August 2022 at 19:03:29 UTC+2, olcott wrote:
>> Within deductive logical inference.
>>
>> Within inductive logical inference only the appeal to an unqualified
>> authority is a fallacy (as I just proved).
> You have failed to prove that the authority you are appealing to is qualified.
>

My purpose was to merely prove that "appeal to authority" is not a
fallacy within inductive inference. When you used the strawman deception
to change the subject that does not change my actual proof at all.

--
Copyright 2022 Pete Olcott

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

On Tue, 16 Aug 2022 10:24:32 -0700 (PDT)
Skep Dick <skepdick22@gmail.com> wrote:

> On Tuesday, 16 August 2022 at 19:18:35 UTC+2, Mr Flibble wrote:
> > Nope; logical fallacies apply to argument and a logical fallacy is
> > always a logical fallacy.
> You are committing the fallacy fallacy!
>
> Just because the argument is fallacious; or and the reasoning is
> incorrect it doesn't mean the conclusion is wrong.
If the conclusion is predicated on faulty reasoning then the
conclusion cannot be trusted and can be dismissed within the context of
the argument irregardless of whether it is actually true or not.

/Flibble

On Tuesday, 16 August 2022 at 19:26:46 UTC+2, olcott wrote:
> My purpose was to merely prove that "appeal to authority" is not a
> fallacy within inductive inference. When you used the strawman deception
> to change the subject that does not change my actual proof at all.
Those are big words you are using there.

None of it changes the fact that you are wrong.

On Tuesday, 16 August 2022 at 19:28:08 UTC+2, Mr Flibble wrote:
> If the conclusion is predicated on faulty reasoning then the
> conclusion cannot be trusted and can be dismissed within the context of
> the argument irregardless of whether it is actually true or not.
None of which has anything to do with whether the conclusion is true; or not.

If the conclusion is true - the premises or the argument (the justification) doesn't matter.

On Tue, 16 Aug 2022 10:36:31 -0700 (PDT)
Skep Dick <skepdick22@gmail.com> wrote:

> On Tuesday, 16 August 2022 at 19:28:08 UTC+2, Mr Flibble wrote:
> > If the conclusion is predicated on faulty reasoning then the
> > conclusion cannot be trusted and can be dismissed within the
> > context of the argument irregardless of whether it is actually true
> > or not.
> None of which has anything to do with whether the conclusion is true;
> or not.
>
> If the conclusion is true - the premises or the argument (the
> justification) doesn't matter.

If you know a priori that the conclusion is true then arguing about it
is pointless.

/Flibble

On 8/16/2022 12:34 PM, Skep Dick wrote:
> On Tuesday, 16 August 2022 at 19:26:46 UTC+2, olcott wrote:
>> My purpose was to merely prove that "appeal to authority" is not a
>> fallacy within inductive inference. When you used the strawman deception
>> to change the subject that does not change my actual proof at all.
> Those are big words you are using there.
>
> None of it changes the fact that you are wrong.
>
>
>
OK so you are only a troll

--
Copyright 2022 Pete Olcott

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

On Tue, 16 Aug 2022 10:36:31 -0700 (PDT)
Skep Dick <skepdick22@gmail.com> wrote:

> On Tuesday, 16 August 2022 at 19:28:08 UTC+2, Mr Flibble wrote:
> > If the conclusion is predicated on faulty reasoning then the
> > conclusion cannot be trusted and can be dismissed within the
> > context of the argument irregardless of whether it is actually true
> > or not.
> None of which has anything to do with whether the conclusion is true;
> or not.
>
> If the conclusion is true - the premises or the argument (the
> justification) doesn't matter.

The conclusion in the following argument can be dismissed as fallacious
even though it is true. Why? Because it is only predicated on the
claims made in the argument it is a part of.

Mr Edgar Authority Expert The Third says all animals have four legs.
A cat has four legs.
Ergo a cat is an animal.

/Flibble

On Tuesday, 16 August 2022 at 19:58:49 UTC+2, olcott wrote:
> On 8/16/2022 12:34 PM, Skep Dick wrote:
> > On Tuesday, 16 August 2022 at 19:26:46 UTC+2, olcott wrote:
> >> My purpose was to merely prove that "appeal to authority" is not a
> >> fallacy within inductive inference. When you used the strawman deception
> >> to change the subject that does not change my actual proof at all.
> > Those are big words you are using there.
> >
> > None of it changes the fact that you are wrong.
> >
> >
> >
> OK so you are only a troll
No, moron.

It is undecidable wheher I am a troll. The fact that you've decided contradicts undecidability.

Ergo - you are wrong.

On Tuesday, 16 August 2022 at 20:02:27 UTC+2, Mr Flibble wrote:
> On Tue, 16 Aug 2022 10:36:31 -0700 (PDT)
> Skep Dick <skepd...@gmail.com> wrote:
>
> > On Tuesday, 16 August 2022 at 19:28:08 UTC+2, Mr Flibble wrote:
> > > If the conclusion is predicated on faulty reasoning then the
> > > conclusion cannot be trusted and can be dismissed within the
> > > context of the argument irregardless of whether it is actually true
> > > or not.
> > None of which has anything to do with whether the conclusion is true;
> > or not.
> >
> > If the conclusion is true - the premises or the argument (the
> > justification) doesn't matter.
> The conclusion in the following argument can be dismissed as fallacious
> even though it is true.
No! The conclusion cannot be dismissed as fallacious BECAUSE the conclusion is true.

The argument is fallacious and can be dismissed, but that doesn't matter.
The conclusion cannot be dismissed because the conclusion is true!

Your conclusion (that the conclusion can be dismissed) is a fallacy.

https://en.wikipedia.org/wiki/Argument_from_fallacy

> Why? Because it is only predicated on the
> claims made in the argument it is a part of.
>
> Mr Edgar Authority Expert The Third says all animals have four legs.
> A cat has four legs.
> Ergo a cat is an animal.
This is practically the same example as the one in the wiki page.

https://en.wikipedia.org/wiki/Argument_from_fallacy#Examples

On 8/16/2022 1:03 PM, Skep Dick wrote:
> On Tuesday, 16 August 2022 at 19:58:49 UTC+2, olcott wrote:
>> On 8/16/2022 12:34 PM, Skep Dick wrote:
>>> On Tuesday, 16 August 2022 at 19:26:46 UTC+2, olcott wrote:
>>>> My purpose was to merely prove that "appeal to authority" is not a
>>>> fallacy within inductive inference. When you used the strawman deception
>>>> to change the subject that does not change my actual proof at all.
>>> Those are big words you are using there.
>>>
>>> None of it changes the fact that you are wrong.
>>>
>>>
>>>
>> OK so you are only a troll
> No, moron.
>
> It is undecidable wheher I am a troll. The fact that you've decided contradicts undecidability.
>
> Ergo - you are wrong.

None-the-less since you have proven to not be interested in an honest
dialogue you will be ignored.

--
Copyright 2022 Pete Olcott

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

On Tuesday, 16 August 2022 at 21:13:50 UTC+2, olcott wrote:
> On 8/16/2022 1:03 PM, Skep Dick wrote:
> > On Tuesday, 16 August 2022 at 19:58:49 UTC+2, olcott wrote:
> >> On 8/16/2022 12:34 PM, Skep Dick wrote:
> >>> On Tuesday, 16 August 2022 at 19:26:46 UTC+2, olcott wrote:
> >>>> My purpose was to merely prove that "appeal to authority" is not a
> >>>> fallacy within inductive inference. When you used the strawman deception
> >>>> to change the subject that does not change my actual proof at all.
> >>> Those are big words you are using there.
> >>>
> >>> None of it changes the fact that you are wrong.
> >>>
> >>>
> >>>
> >> OK so you are only a troll
> > No, moron.
> >
> > It is undecidable wheher I am a troll. The fact that you've decided contradicts undecidability.
> >
> > Ergo - you are wrong.
> None-the-less since you have proven to not be interested in an honest
> dialogue you will be ignored.
Q.E.D

honest/dishonest are undecidable.

But you have decided.

So you are wrong.

On 8/16/22 10:27 AM, olcott wrote:
> On 8/16/2022 9:07 AM, Skep Dick wrote:
>> On Tuesday, 16 August 2022 at 15:55:30 UTC+2, olcott wrote:
>>> The correct and complete x86 emulation of the input to H(P,P) by H WOULD
>>> never stop running.
>> Sounds like you are stuck in a loop.
>>
>> Maybe your Decider/Maker should terminate you.
>>
>
> I have been trying to get an honest person to acknowledge the correct
> software engineering of my system so that we can move on to the next
> point for a year now. (bot many honest people here, mostly trolls).

The problem is that what you say ISN'T CORRECT software engineering.

You use the wrong definition of things and incorrect assumptions about
thing, so it just isn't true.

>
> H(P,P) does correctly predict that its correct and complete x86
> emulation of its input would never stop running, thus does correctly
> reject this input as non-halting.
>

Nope. And in fact, you even acknoldge it doesn't but just don't see it.

> *The next point after this point is why can't a TM do the same thing*?
>

On 8/16/22 10:37 AM, olcott wrote:
> On 8/16/2022 9:30 AM, Skep Dick wrote:
>> On Tuesday, 16 August 2022 at 16:27:14 UTC+2, olcott wrote:
>>> On 8/16/2022 9:07 AM, Skep Dick wrote:
>>>> On Tuesday, 16 August 2022 at 15:55:30 UTC+2, olcott wrote:
>>>>> The correct and complete x86 emulation of the input to H(P,P) by H
>>>>> WOULD
>>>>> never stop running.
>>>> Sounds like you are stuck in a loop.
>>>>
>>>> Maybe your Decider/Maker should terminate you.
>>>>
>>> I have been trying to get an honest person to acknowledge the correct
>>> software engineering of my system so that we can move on to the next
>>> point for a year now. (bot many honest people here, mostly trolls).
>>> H(P,P) does correctly predict that its correct and complete x86
>>> emulation of its input would never stop running, thus does correctly
>>> reject this input as non-halting.
>>>
>>> *The next point after this point is why can't a TM do the same thing*?
>> A Turing Machine can and does do the EXACT SAME THING!
>>
>> It's literally in Turing's paper (had you bothered to read it).
>>
>
> A computer scientist that has been published in CACM says that because H
> does not return a value when it is called in infinite recursion it is
> not a pure function thus not Turing computable.

If he said that, he just disproved your statement,

If H isn't a Pure Function, even though you have been claiming it is,
then your proof just falls apart.

Just proves how badly you understand what people say.

>
> It seems to me that when CS requires a function to return a value when
> it is called in infinite recursion and software engineering forbids this
> that either CS or SE must be incorrect.

The problem is that the H(P,P) that returns 0 ISN'T called in infinite
recursion, because ALL copies of it will abort there simulation at the
same point in their processing.

Thus, there isn't a problem.

>
>> There is a hierarchy of Turing computability.
>> A machine which is higher in the hierarchy (more powerful) can solve
>> the halting problem for a machine lower in the hierarchy (less powerful).
>>
>> All you've demonstrated is precisely THAT your halt decider is a more
>> powerful program than the program it's deciding on.
>>
>> Boring.
>
>

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

On 8/16/2022 8:10 PM, Richard Damon wrote:
> On 8/16/22 10:27 AM, olcott wrote:
>> On 8/16/2022 9:07 AM, Skep Dick wrote:
>>> On Tuesday, 16 August 2022 at 15:55:30 UTC+2, olcott wrote:
>>>> The correct and complete x86 emulation of the input to H(P,P) by H
>>>> WOULD
>>>> never stop running.
>>> Sounds like you are stuck in a loop.
>>>
>>> Maybe your Decider/Maker should terminate you.
>>>
>>
>> I have been trying to get an honest person to acknowledge the correct
>> software engineering of my system so that we can move on to the next
>> point for a year now. (bot many honest people here, mostly trolls).
>
> The problem is that what you say ISN'T CORRECT software engineering.
>
> You use the wrong definition of things and incorrect assumptions about
> thing, so it just isn't true.
>
>>
>> H(P,P) does correctly predict that its correct and complete x86
>> emulation of its input would never stop running, thus does correctly
>> reject this input as non-halting.
>>
>
> Nope. And in fact, you even acknoldge it doesn't but just don't see it.
>

So you are saying that the correct and complete x86 emulation by H(P,P)
of its input WOULD STOP RUNNING?

--
Copyright 2022 Pete Olcott

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

On 8/16/2022 8:14 PM, Richard Damon wrote:
> On 8/16/22 10:37 AM, olcott wrote:
>> On 8/16/2022 9:30 AM, Skep Dick wrote:
>>> On Tuesday, 16 August 2022 at 16:27:14 UTC+2, olcott wrote:
>>>> On 8/16/2022 9:07 AM, Skep Dick wrote:
>>>>> On Tuesday, 16 August 2022 at 15:55:30 UTC+2, olcott wrote:
>>>>>> The correct and complete x86 emulation of the input to H(P,P) by H
>>>>>> WOULD
>>>>>> never stop running.
>>>>> Sounds like you are stuck in a loop.
>>>>>
>>>>> Maybe your Decider/Maker should terminate you.
>>>>>
>>>> I have been trying to get an honest person to acknowledge the correct
>>>> software engineering of my system so that we can move on to the next
>>>> point for a year now. (bot many honest people here, mostly trolls).
>>>> H(P,P) does correctly predict that its correct and complete x86
>>>> emulation of its input would never stop running, thus does correctly
>>>> reject this input as non-halting.
>>>>
>>>> *The next point after this point is why can't a TM do the same thing*?
>>> A Turing Machine can and does do the EXACT SAME THING!
>>>
>>> It's literally in Turing's paper (had you bothered to read it).
>>>
>>
>> A computer scientist that has been published in CACM says that because
>> H does not return a value when it is called in infinite recursion it
>> is not a pure function thus not Turing computable.
>
> If he said that, he just disproved your statement,

*Not at all. No one has disproved this statement*
H(P,P) does correctly predict that its correct and complete x86
emulation of its input would never stop running, thus does correctly
reject this input as non-halting.

Every attempt to "disprove" that statement twists its words and
disproves the twisted words.

--
Copyright 2022 Pete Olcott

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

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

On 8/16/22 9:20 PM, olcott wrote:
> On 8/16/2022 8:10 PM, Richard Damon wrote:
>> On 8/16/22 10:27 AM, olcott wrote:
>>> On 8/16/2022 9:07 AM, Skep Dick wrote:
>>>> On Tuesday, 16 August 2022 at 15:55:30 UTC+2, olcott wrote:
>>>>> The correct and complete x86 emulation of the input to H(P,P) by H
>>>>> WOULD
>>>>> never stop running.
>>>> Sounds like you are stuck in a loop.
>>>>
>>>> Maybe your Decider/Maker should terminate you.
>>>>
>>>
>>> I have been trying to get an honest person to acknowledge the correct
>>> software engineering of my system so that we can move on to the next
>>> point for a year now. (bot many honest people here, mostly trolls).
>>
>> The problem is that what you say ISN'T CORRECT software engineering.
>>
>> You use the wrong definition of things and incorrect assumptions about
>> thing, so it just isn't true.
>>
>>>
>>> H(P,P) does correctly predict that its correct and complete x86
>>> emulation of its input would never stop running, thus does correctly
>>> reject this input as non-halting.
>>>
>>
>> Nope. And in fact, you even acknoldge it doesn't but just don't see it.
>>
>
> So you are saying that the correct and complete x86 emulation by H(P,P)
> of its input WOULD STOP RUNNING?
>

No, I am saying that you H doesn't do a correct and complete emulation
of its input, and thus to say it did is just a LIE.

Yes, there is ANOTHER machine that you deceitfully also call H, the Hn
that never aborts, and yes, for that Hn, it does correctly and
completely emulate its input of PN(Pn) and that is non-halting, but Hn
fails to answer, so doesn't give the correct answer either.

You decietfully confuse the two H's which are DIFFERENT deciders, to try
to make you point.

BOTH FAIL, but in different ways.

YOU ARE JUST A DECEITFUL LIAR.

On 8/16/22 9:23 PM, olcott wrote:
> On 8/16/2022 8:14 PM, Richard Damon wrote:
>> On 8/16/22 10:37 AM, olcott wrote:
>>> On 8/16/2022 9:30 AM, Skep Dick wrote:
>>>> On Tuesday, 16 August 2022 at 16:27:14 UTC+2, olcott wrote:
>>>>> On 8/16/2022 9:07 AM, Skep Dick wrote:
>>>>>> On Tuesday, 16 August 2022 at 15:55:30 UTC+2, olcott wrote:
>>>>>>> The correct and complete x86 emulation of the input to H(P,P) by
>>>>>>> H WOULD
>>>>>>> never stop running.
>>>>>> Sounds like you are stuck in a loop.
>>>>>>
>>>>>> Maybe your Decider/Maker should terminate you.
>>>>>>
>>>>> I have been trying to get an honest person to acknowledge the correct
>>>>> software engineering of my system so that we can move on to the next
>>>>> point for a year now. (bot many honest people here, mostly trolls).
>>>>> H(P,P) does correctly predict that its correct and complete x86
>>>>> emulation of its input would never stop running, thus does correctly
>>>>> reject this input as non-halting.
>>>>>
>>>>> *The next point after this point is why can't a TM do the same thing*?
>>>> A Turing Machine can and does do the EXACT SAME THING!
>>>>
>>>> It's literally in Turing's paper (had you bothered to read it).
>>>>
>>>
>>> A computer scientist that has been published in CACM says that
>>> because H does not return a value when it is called in infinite
>>> recursion it is not a pure function thus not Turing computable.
>>
>> If he said that, he just disproved your statement,
>
> *Not at all. No one has disproved this statement*
> H(P,P) does correctly predict that its correct and complete x86
> emulation of its input would never stop running, thus does correctly
> reject this input as non-halting.
>
> Every attempt to "disprove" that statement twists its words and
> disproves the twisted words.
>

LIE.

I know I have, and so have others.

You are just too stupid to understand it because YOU use incorrect
definitions to try to twist your words.

Please show EXACTLY which words I have "twisted", and what the correct
meaning is.

I DARE YOU.

Otherwise, you are just proved to be a LIAR.

A DAMNED LIAR.

On 8/16/22 9:27 PM, olcott wrote:
> On 8/16/2022 8:20 PM, Richard Damon wrote:
>>
>> On 8/16/22 9:44 AM, olcott wrote:
>>> On 8/16/2022 6:16 AM, Richard Damon wrote:
>>>> On 8/15/22 11:28 PM, olcott wrote:
>>>>> The C function H(P,P) does correctly predict that its correct and
>>>>> complete x86 emulation of its input would never stop running unless
>>>>> and until it aborts its x86 emulation of this input.
>>>>>
>>>>>
>>>>>
>>>>
>>>> No, it doesn't.
>>>>
>>>> The Correct and Complete x86 emulation of the program P(P) Halts,
>>>
>>> Again you lie. The correct and complete x86 emulation of the input to
>>> H(P,P) by H never stops running.
>>>
>>>
>>
>> The problem is that your H (at least those that answer) don't do a
>> complete and correct x86 emultion of their input, so your statement is
>> vacuous and unsound.
>>
> correctly predict
> correctly predict
> correctly predict
> correctly predict
> correctly predict
> correctly predict
> correctly predict
> correctly predict
>
>

How can you correctly predict about a behavior that never happens.

You forget that the H you are talking about isn't just some abstract
idea of a Decider, but an actual particular instance of one.

That H DOES abort its simulation, so asking about the complete
simulation is asking about something that just didn't happen.

What color was The famous Napoleon Bonaparte's shoes when he landed on Mars?

There is no answer, as it didn't happen. Just like there is no answer
about the complete simulation done by THIS H, since it didn't do one.

It is a DIFFERENT H that does the complete simulation, one that nevers
answers.