On 9/1/2022 10:19 AM, Paul N wrote:
> On Thursday, September 1, 2022 at 4:43:18 AM UTC+1, olcott wrote:
>> You are not going to be able to understand the next step until you
>> understand that the prior step is true.
>>
>> H(PP,PP)==0 is stipulated to mean that Simulate(Pz,Pz) never halts.
>
> Just to clarify, you are claiming that H(PP,PP)==0 is stipulated to mean that Simulate(Pz,Pz) never halts?
>

Simulate(Pz,Pz) is the way of encoding the correct and complete
simulation of the input H(P,P) by H.

void P(ptr x)
{ int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return;
}

We don't really need to change the name from P to Pz because P remains
this exact same machine language byte string:
558bec518b4508508b4d0851e82ffdffff83c4088945fc837dfc007402ebfe8be55dc3

H always bases its halt status decision on the behavior of the pure
simulation of its input as if H itself was a pure simulator and not a
halt decider.

H0(Infinite_Loop) reports on the behavior of Simulate(Infinite_Loop)
*THE HYPOTHETICAL CASE WHERE H NEVER ABORTS ITS SIMULATION*

H(Infinite_Recursion, 0x777) reports on the behavior of
Simulate(H(Infinite_Recursion, 0x777)
*THE HYPOTHETICAL CASE WHERE H NEVER ABORTS ITS SIMULATION*

H(P,P) reports on the behavior of:
void P(ptr x)
{ int Halt_Status = Simulate(x, x);
if (Halt_Status)
HERE: goto HERE;
return;
} *THE HYPOTHETICAL CASE WHERE H NEVER ABORTS ITS SIMULATION*

P is physically unchanged.
558bec518b4508508b4d0851e82ffdffff83c4088945fc837dfc007402ebfe8be55dc3

H is is physically unchanged. H reports on whether or not its input
stops running in the hypothetical case where H never aborts the
simulation of this input.

Every simulating halt decider must always report on hypothetical cases
where it correctly predicts non-halting behavior.

> You are not claiming that H(PP,PP)==0 is stipulated to mean that Simulate(PP,PP) never halts?
>
> You are not claiming that H(PP,PP)==0 is stipulated to mean that PP(PP) never halts?
>
> You are not claiming that H is a halt decider?
>
> You are not claiming that H refutes the well-known proof that a halt decider cannot exist?

--
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 Thu, 1 Sep 2022 08:19:29 -0700 (PDT)
Paul N <gw7rib@aol.com> wrote:

> You are not claiming that H refutes the well-known proof that a halt
> decider cannot exist?

The well-known proof is the "Impossible Program" contradiction and I
have invented a halt decider that can detect that contradiction ergo
the Flibble Signaling Halt Decider (tm) refutes that well-known proof.

/Flibble

On 9/1/2022 10:38 AM, Mr Flibble wrote:
> On Thu, 1 Sep 2022 08:19:29 -0700 (PDT)
> Paul N <gw7rib@aol.com> wrote:
>
>> You are not claiming that H refutes the well-known proof that a halt
>> decider cannot exist?
>
> The well-known proof is the "Impossible Program" contradiction and I

That is your one key insight, and it does apply to Gödel's 1931
incompleteness theorem, the Tarski Undefinability theorem and the Liar
Paradox yet does not apply to the halting theorem.

> have invented a halt decider that can detect that contradiction ergo
> the Flibble Signaling Halt Decider (tm) refutes that well-known proof.
>
> /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

Mr Flibble <flibble@reddwarf.jmc.corp> writes:

> On Thu, 1 Sep 2022 08:19:29 -0700 (PDT)
> Paul N <gw7rib@aol.com> wrote:
>
>> You are not claiming that H refutes the well-known proof that a halt
>> decider cannot exist?
>
> The well-known proof is the "Impossible Program" contradiction and I
> have invented a halt decider that can detect that contradiction ergo
> the Flibble Signaling Halt Decider (tm) refutes that well-known proof.

The well-known proof is about deciders. Not about functions that are
not deciders. Not deciding is easy.

Every time one teaches this material this "solution" comes up -- just
detect the "pathological" case and abort, or signal, or return a third
result, or don't return at all, or... (the detail about how to avoid
deciding vary).

--
Ben.

On Thu, 01 Sep 2022 17:05:54 +0100
Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:

> Mr Flibble <flibble@reddwarf.jmc.corp> writes:
>
> > On Thu, 1 Sep 2022 08:19:29 -0700 (PDT)
> > Paul N <gw7rib@aol.com> wrote:
> >
> >> You are not claiming that H refutes the well-known proof that a
> >> halt decider cannot exist?
> >
> > The well-known proof is the "Impossible Program" contradiction and I
> > have invented a halt decider that can detect that contradiction ergo
> > the Flibble Signaling Halt Decider (tm) refutes that well-known
> > proof.
>
> The well-known proof is about deciders. Not about functions that are
> not deciders. Not deciding is easy.
>
> Every time one teaches this material this "solution" comes up -- just
> detect the "pathological" case and abort, or signal, or return a third
> result, or don't return at all, or... (the detail about how to avoid
> deciding vary).

You are a liar: I am the first to invent a decider that can detect the
pathological case: prove me wrong.

/Flibble

On 9/1/2022 11:05 AM, Ben Bacarisse wrote:
> Mr Flibble <flibble@reddwarf.jmc.corp> writes:
>
>> On Thu, 1 Sep 2022 08:19:29 -0700 (PDT)
>> Paul N <gw7rib@aol.com> wrote:
>>
>>> You are not claiming that H refutes the well-known proof that a halt
>>> decider cannot exist?
>>
>> The well-known proof is the "Impossible Program" contradiction and I
>> have invented a halt decider that can detect that contradiction ergo
>> the Flibble Signaling Halt Decider (tm) refutes that well-known proof.
>
> The well-known proof is about deciders. Not about functions that are
> not deciders. Not deciding is easy.
>
> Every time one teaches this material this "solution" comes up -- just
> detect the "pathological" case and abort, or signal, or return a third
> result, or don't return at all, or... (the detail about how to avoid
> deciding vary).
>

// P does the opposite of whatever H decides
void P(ptr x)
{ int Halt_Status = H(x, x);
if (Halt_Status) // if H(P,P) reports that its input halts
HERE: goto HERE; // P loops and never halts
return; // else P halts
}

In my earlier work:
What H(P,P) is aspect the question: Does your input halt?
and the answer is restricted to a return value from H to P

Both answers of YES and NO are incorrect, thus proving a pathological
input, thus an incorrect question.

When the question: What times is it? is restricted to YES or NO
Both answers of YES and NO are incorrect, thus an incorrect question.

When-so-ever and YES/NO question has no possible correct YES/NO answer
then the question itself is incorrect.

My logical law of polar questions copyright 2015:
https://groups.google.com/g/sci.lang/c/AO5Vlupeelo/m/nxJy7N2vULwJ

--
Copyright 2022 Pete Olcott "Talent hits a target no one else can hit;
Genius hits a target no one else can see." Arthur Schopenhauer

Mr Flibble <flibble@reddwarf.jmc.corp> writes:

> On Thu, 01 Sep 2022 17:05:54 +0100
> Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
>
>> Mr Flibble <flibble@reddwarf.jmc.corp> writes:
>>
>> > On Thu, 1 Sep 2022 08:19:29 -0700 (PDT)
>> > Paul N <gw7rib@aol.com> wrote:
>> >
>> >> You are not claiming that H refutes the well-known proof that a
>> >> halt decider cannot exist?
>> >
>> > The well-known proof is the "Impossible Program" contradiction and I
>> > have invented a halt decider that can detect that contradiction ergo
>> > the Flibble Signaling Halt Decider (tm) refutes that well-known
>> > proof.
>>
>> The well-known proof is about deciders. Not about functions that are
>> not deciders. Not deciding is easy.
>>
>> Every time one teaches this material this "solution" comes up -- just
>> detect the "pathological" case and abort, or signal, or return a third
>> result, or don't return at all, or... (the detail about how to avoid
>> deciding vary).
>
> You are a liar: I am the first to invent a decider that can detect the
> pathological case: prove me wrong.

None of the students wrote papers about non-deciders so how could I
prove that this comes up every time? But I will put my reputation for
honesty here up against anyone. I don't lie.

Of course, you could submit what you consider to be am entirely new idea
to a journal and see what they say.

What is indisputable is that what you call a decider is not a decider.
A decider accepts or rejects every problem instance.

--
Ben.

On 2022-09-01 08:31, olcott wrote:

> When I stipulate that H(P,P)==0 is code for Simulate(Pz,Pz) never stops
> running then H(P,P)==0 is true.
>
> In BASIC when
> 100 let X = 5
> when it not free to interprets that value of X as anthing besides 5.

You're free to stipulate that X = 5, but what you are trying to do is
more akin to stipulating that 2 + 2 = 5.

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

On Thu, 01 Sep 2022 17:40:46 +0100
Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:

> Mr Flibble <flibble@reddwarf.jmc.corp> writes:
>
> > On Thu, 01 Sep 2022 17:05:54 +0100
> > Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
> >
> >> Mr Flibble <flibble@reddwarf.jmc.corp> writes:
> >>
> >> > On Thu, 1 Sep 2022 08:19:29 -0700 (PDT)
> >> > Paul N <gw7rib@aol.com> wrote:
> >> >
> >> >> You are not claiming that H refutes the well-known proof that a
> >> >> halt decider cannot exist?
> >> >
> >> > The well-known proof is the "Impossible Program" contradiction
> >> > and I have invented a halt decider that can detect that
> >> > contradiction ergo the Flibble Signaling Halt Decider (tm)
> >> > refutes that well-known proof.
> >>
> >> The well-known proof is about deciders. Not about functions that
> >> are not deciders. Not deciding is easy.
> >>
> >> Every time one teaches this material this "solution" comes up --
> >> just detect the "pathological" case and abort, or signal, or
> >> return a third result, or don't return at all, or... (the detail
> >> about how to avoid deciding vary).
> >
> > You are a liar: I am the first to invent a decider that can detect
> > the pathological case: prove me wrong.
>
> None of the students wrote papers about non-deciders so how could I
> prove that this comes up every time? But I will put my reputation for
> honesty here up against anyone. I don't lie.

So you have failed to prove me wrong: I am the first to invent a
decider that can detect pathological input THAT WORKS.

>
> Of course, you could submit what you consider to be am entirely new
> idea to a journal and see what they say.

I have already published my novel decider both in this forum and on
GitHub:

https://github.com/i42output/halting-problem#readme

>
> What is indisputable is that what you call a decider is not a decider.
> A decider accepts or rejects every problem instance.

What is indisputable is that pathological input neither halts nor
doesn't halt so not giving a decision of halt or doesn't halt IS THE
CORRECT THING TO DO.

/Flibble

On 9/1/2022 11:43 AM, André G. Isaak wrote:
> On 2022-09-01 08:31, olcott wrote:
>
>> When I stipulate that H(P,P)==0 is code for Simulate(Pz,Pz) never
>> stops running then H(P,P)==0 is true.
>>
>> In BASIC when
>> 100 let X = 5
>> when it not free to interprets that value of X as anthing besides 5.
>
> You're free to stipulate that X = 5, but what you are trying to do is
> more akin to stipulating that 2 + 2 = 5.
>
> André
>

*Not at all*
A simulating halt decider must map its input finite string to an accept
or reject state on the basis of whether or not it must abort its
otherwise complete simulation of its input to prevent the infinite
simulation of this input.

int sum(int x, int y)
{ return x + y;
}

H0(Infinite_Loop)==0
H(Infinite_Recursion, 0x777)==0
H(P,P)==0
H2(sum,2,3)==1

All perfectly meet this definition.

--
Copyright 2022 Pete Olcott "Talent hits a target no one else can hit;
Genius hits a target no one else can see." Arthur Schopenhauer

Mr Flibble <flibble@reddwarf.jmc.corp> writes:

> On Thu, 01 Sep 2022 17:40:46 +0100
> Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
>
>> Mr Flibble <flibble@reddwarf.jmc.corp> writes:
>>
>> > On Thu, 01 Sep 2022 17:05:54 +0100
>> > Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
>> >
>> >> Mr Flibble <flibble@reddwarf.jmc.corp> writes:
>> >>
>> >> > On Thu, 1 Sep 2022 08:19:29 -0700 (PDT)
>> >> > Paul N <gw7rib@aol.com> wrote:
>> >> >
>> >> >> You are not claiming that H refutes the well-known proof that a
>> >> >> halt decider cannot exist?
>> >> >
>> >> > The well-known proof is the "Impossible Program" contradiction
>> >> > and I have invented a halt decider that can detect that
>> >> > contradiction ergo the Flibble Signaling Halt Decider (tm)
>> >> > refutes that well-known proof.
>> >>
>> >> The well-known proof is about deciders. Not about functions that
>> >> are not deciders. Not deciding is easy.
>> >>
>> >> Every time one teaches this material this "solution" comes up --
>> >> just detect the "pathological" case and abort, or signal, or
>> >> return a third result, or don't return at all, or... (the detail
>> >> about how to avoid deciding vary).
>> >
>> > You are a liar: I am the first to invent a decider that can detect
>> > the pathological case: prove me wrong.
>>
>> None of the students wrote papers about non-deciders so how could I
>> prove that this comes up every time? But I will put my reputation for
>> honesty here up against anyone. I don't lie.
>
> So you have failed to prove me wrong: I am the first to invent a
> decider that can detect pathological input THAT WORKS.

You are not. But neither claim can be easily proved. What is certain
is that you do not have a decider.

>> Of course, you could submit what you consider to be am entirely new
>> idea to a journal and see what they say.
>
> I have already published my novel decider both in this forum and on
> GitHub:

I meant, as you know, somewhere that cares about quality. The journal
editor will tell you it's not a new idea. They won't be able to prove
it either (since it's trivial), but they won't publish it.

>> What is indisputable is that what you call a decider is not a decider.
>> A decider accepts or rejects every problem instance.
>
> What is indisputable is that pathological input neither halts nor
> doesn't halt so not giving a decision of halt or doesn't halt IS THE
> CORRECT THING TO DO.

That is incorrect. It's wrong in several ways. First no input halts
and no input does not halt. Halting is not an intrinsic property of
inputs, but a property of the computations they represent. Second, all
computations (in the sense of Strachey's letter) either halt or they
don't. What do you think the "others" do?

As usual, by avoiding a formal model (like TMs, lambda calculus,
combinator forms, etc) you introduce enough waffle to be able to boast
about your achievement to your heart's content. That's pretty much what
it's all about -- boasting.

--
Ben.

On Thursday, September 1, 2022 at 4:36:51 PM UTC+1, olcott wrote:
> On 9/1/2022 10:19 AM, Paul N wrote:
> > On Thursday, September 1, 2022 at 4:43:18 AM UTC+1, olcott wrote:
> >> You are not going to be able to understand the next step until you
> >> understand that the prior step is true.
> >>
> >> H(PP,PP)==0 is stipulated to mean that Simulate(Pz,Pz) never halts..
> >
> > Just to clarify, you are claiming that H(PP,PP)==0 is stipulated to mean that Simulate(Pz,Pz) never halts?
> >
> Simulate(Pz,Pz) is the way of encoding the correct and complete
> simulation of the input H(P,P) by H.
>
> void P(ptr x)
> {
> int Halt_Status = H(x, x);
> if (Halt_Status)
> HERE: goto HERE;
> return;
> }
>
> We don't really need to change the name from P to Pz because P remains
> this exact same machine language byte string:
> 558bec518b4508508b4d0851e82ffdffff83c4088945fc837dfc007402ebfe8be55dc3
>
> H always bases its halt status decision on the behavior of the pure
> simulation of its input as if H itself was a pure simulator and not a
> halt decider.
>
> H0(Infinite_Loop) reports on the behavior of Simulate(Infinite_Loop)
> *THE HYPOTHETICAL CASE WHERE H NEVER ABORTS ITS SIMULATION*

These last two paragraphs are exactly the crux of the problem.

The point is that P calls H. So if you change H, you are potentially changing the behaviour of P. So H is not reporting on the exact code it is considering, it is reporting on something else.

As I said in another post, H is being asked to do an impossible job, which is why it fails to do it. You seem to think that P and H are just normal programs which, if you're careful enough, it ought to be possible to simulate and predict. You're too hooked up on the simulating bit, and you fail to notice that H's job is impossible.

> H(Infinite_Recursion, 0x777) reports on the behavior of
> Simulate(H(Infinite_Recursion, 0x777)
> *THE HYPOTHETICAL CASE WHERE H NEVER ABORTS ITS SIMULATION*
>
> H(P,P) reports on the behavior of:
> void P(ptr x)
> {
> int Halt_Status = Simulate(x, x);
> if (Halt_Status)
> HERE: goto HERE;
> return;
> }
> *THE HYPOTHETICAL CASE WHERE H NEVER ABORTS ITS SIMULATION*

Exactly. You have just said, in capitals and with asterisks, that H is not reporting on what actually happens.

> P is physically unchanged.
> 558bec518b4508508b4d0851e82ffdffff83c4088945fc837dfc007402ebfe8be55dc3
>
> H is is physically unchanged. H reports on whether or not its input
> stops running in the hypothetical case where H never aborts the
> simulation of this input.
>
> Every simulating halt decider must always report on hypothetical cases
> where it correctly predicts non-halting behavior.

Since H has to give an answer within a finite time, it does indeed have to work out what *would* happen, rather than run the simulation all the way through. But it must simulate what the *actual* code would do, rather than what different code (ie code with a different H) would do.

> > You are not claiming that H(PP,PP)==0 is stipulated to mean that Simulate(PP,PP) never halts?
> >
> > You are not claiming that H(PP,PP)==0 is stipulated to mean that PP(PP) never halts?
> >
> > You are not claiming that H is a halt decider?
> >
> > You are not claiming that H refutes the well-known proof that a halt decider cannot exist?

On 9/1/2022 1:15 PM, Paul N wrote:
> On Thursday, September 1, 2022 at 4:36:51 PM UTC+1, olcott wrote:
>> On 9/1/2022 10:19 AM, Paul N wrote:
>>> On Thursday, September 1, 2022 at 4:43:18 AM UTC+1, olcott wrote:
>>>> You are not going to be able to understand the next step until you
>>>> understand that the prior step is true.
>>>>
>>>> H(PP,PP)==0 is stipulated to mean that Simulate(Pz,Pz) never halts.
>>>
>>> Just to clarify, you are claiming that H(PP,PP)==0 is stipulated to mean that Simulate(Pz,Pz) never halts?
>>>
>> Simulate(Pz,Pz) is the way of encoding the correct and complete
>> simulation of the input H(P,P) by H.
>>
>> void P(ptr x)
>> {
>> int Halt_Status = H(x, x);
>> if (Halt_Status)
>> HERE: goto HERE;
>> return;
>> }
>>
>> We don't really need to change the name from P to Pz because P remains
>> this exact same machine language byte string:
>> 558bec518b4508508b4d0851e82ffdffff83c4088945fc837dfc007402ebfe8be55dc3
>>
>> H always bases its halt status decision on the behavior of the pure
>> simulation of its input as if H itself was a pure simulator and not a
>> halt decider.
>>
>> H0(Infinite_Loop) reports on the behavior of Simulate(Infinite_Loop)
>> *THE HYPOTHETICAL CASE WHERE H NEVER ABORTS ITS SIMULATION*
>
> These last two paragraphs are exactly the crux of the problem.
>
> The point is that P calls H. So if you change H, you are potentially changing the behaviour of P. So H is not reporting on the exact code it is considering, it is reporting on something else.
>

The decisive point is that P cannot possibly reach its own final state
thus conclusively proving that P never halts.

> As I said in another post, H is being asked to do an impossible job, which is why it fails to do it. You seem to think that P and H are just normal programs which, if you're careful enough, it ought to be possible to simulate and predict. You're too hooked up on the simulating bit, and you fail to notice that H's job is impossible.

That I wrote them in C and execute them proves that they are not mere
incorrect imaginings.

In incorrect imagining is that any H must ever return a value to its
simulated P.

>
>> H(Infinite_Recursion, 0x777) reports on the behavior of
>> Simulate(H(Infinite_Recursion, 0x777)
>> *THE HYPOTHETICAL CASE WHERE H NEVER ABORTS ITS SIMULATION*
>>
>> H(P,P) reports on the behavior of:
>> void P(ptr x)
>> {
>> int Halt_Status = Simulate(x, x);
>> if (Halt_Status)
>> HERE: goto HERE;
>> return;
>> }
>> *THE HYPOTHETICAL CASE WHERE H NEVER ABORTS ITS SIMULATION*
>
> Exactly. You have just said, in capitals and with asterisks, that H is not reporting on what actually happens.

A simulating halt decider must always predict the behavior of its
correct and complete simulation of its input.

H0(Infinite_Loop)
Reports that its correct and complete simulation of its input never
stops running.

H(Infinite_Recursion, 0x777)
Reports that its correct and complete simulation of its input never
stops running.

H(P, P)
Reports that its correct and complete simulation of its input never
stops running.

>
>> P is physically unchanged.
>> 558bec518b4508508b4d0851e82ffdffff83c4088945fc837dfc007402ebfe8be55dc3
>>
>> H is is physically unchanged. H reports on whether or not its input
>> stops running in the hypothetical case where H never aborts the
>> simulation of this input.
>>
>> Every simulating halt decider must always report on hypothetical cases
>> where it correctly predicts non-halting behavior.
>
> Since H has to give an answer within a finite time, it does indeed have to work out what *would* happen, rather than run the simulation all the way through. But it must simulate what the *actual* code would do,

These machine code bytes do not change:
558bec518b4508508b4d0851e82ffdffff83c4088945fc837dfc007402ebfe8be55dc3

The correct and complete simulation of a machine description is the
definitive measure of the behavior of this machine description.

When H performs a correct simulation of this finite string:
558bec518b4508508b4d0851e82ffdffff83c4088945fc837dfc007402ebfe8be55dc3

an infinite behavior pattern is matched indicating that H must abort the
simulation of this otherwise non-terminating input.

> rather than what different code (ie code with a different H) would do.
>
>>> You are not claiming that H(PP,PP)==0 is stipulated to mean that Simulate(PP,PP) never halts?
>>>
>>> You are not claiming that H(PP,PP)==0 is stipulated to mean that PP(PP) never halts?
>>>
>>> You are not claiming that H is a halt decider?
>>>
>>> You are not claiming that H refutes the well-known proof that a halt decider cannot exist?

--
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 Thursday, September 1, 2022 at 7:33:22 PM UTC+1, olcott wrote:
> On 9/1/2022 1:15 PM, Paul N wrote:
> > On Thursday, September 1, 2022 at 4:36:51 PM UTC+1, olcott wrote:
> >> On 9/1/2022 10:19 AM, Paul N wrote:
> >>> On Thursday, September 1, 2022 at 4:43:18 AM UTC+1, olcott wrote:
> >>>> You are not going to be able to understand the next step until you
> >>>> understand that the prior step is true.
> >>>>
> >>>> H(PP,PP)==0 is stipulated to mean that Simulate(Pz,Pz) never halts.
> >>>
> >>> Just to clarify, you are claiming that H(PP,PP)==0 is stipulated to mean that Simulate(Pz,Pz) never halts?
> >>>
> >> Simulate(Pz,Pz) is the way of encoding the correct and complete
> >> simulation of the input H(P,P) by H.
> >>
> >> void P(ptr x)
> >> {
> >> int Halt_Status = H(x, x);
> >> if (Halt_Status)
> >> HERE: goto HERE;
> >> return;
> >> }
> >>
> >> We don't really need to change the name from P to Pz because P remains
> >> this exact same machine language byte string:
> >> 558bec518b4508508b4d0851e82ffdffff83c4088945fc837dfc007402ebfe8be55dc3
> >>
> >> H always bases its halt status decision on the behavior of the pure
> >> simulation of its input as if H itself was a pure simulator and not a
> >> halt decider.
> >>
> >> H0(Infinite_Loop) reports on the behavior of Simulate(Infinite_Loop)
> >> *THE HYPOTHETICAL CASE WHERE H NEVER ABORTS ITS SIMULATION*
> >
> > These last two paragraphs are exactly the crux of the problem.
> >
> > The point is that P calls H. So if you change H, you are potentially changing the behaviour of P. So H is not reporting on the exact code it is considering, it is reporting on something else.
> >
> The decisive point is that P cannot possibly reach its own final state
> thus conclusively proving that P never halts.

But you have told us numerous times that P does in fact halt. Any "conclusive proof" that it doesn't is clearly wrong.

> > As I said in another post, H is being asked to do an impossible job, which is why it fails to do it. You seem to think that P and H are just normal programs which, if you're careful enough, it ought to be possible to simulate and predict. You're too hooked up on the simulating bit, and you fail to notice that H's job is impossible.
> That I wrote them in C and execute them proves that they are not mere
> incorrect imaginings.
>
> In incorrect imagining is that any H must ever return a value to its
> simulated P.
> >
> >> H(Infinite_Recursion, 0x777) reports on the behavior of
> >> Simulate(H(Infinite_Recursion, 0x777)
> >> *THE HYPOTHETICAL CASE WHERE H NEVER ABORTS ITS SIMULATION*
> >>
> >> H(P,P) reports on the behavior of:
> >> void P(ptr x)
> >> {
> >> int Halt_Status = Simulate(x, x);
> >> if (Halt_Status)
> >> HERE: goto HERE;
> >> return;
> >> }
> >> *THE HYPOTHETICAL CASE WHERE H NEVER ABORTS ITS SIMULATION*
> >
> > Exactly. You have just said, in capitals and with asterisks, that H is not reporting on what actually happens.
> A simulating halt decider must always predict the behavior of its
> correct and complete simulation of its input.
>
> H0(Infinite_Loop)
> Reports that its correct and complete simulation of its input never
> stops running.
>
> H(Infinite_Recursion, 0x777)
> Reports that its correct and complete simulation of its input never
> stops running.
>
> H(P, P)
> Reports that its correct and complete simulation of its input never
> stops running.

Which is wrong, because P(P) halts and so a correct and complete simulation would also halt.

> >> P is physically unchanged.
> >> 558bec518b4508508b4d0851e82ffdffff83c4088945fc837dfc007402ebfe8be55dc3
> >>
> >> H is is physically unchanged. H reports on whether or not its input
> >> stops running in the hypothetical case where H never aborts the
> >> simulation of this input.
> >>
> >> Every simulating halt decider must always report on hypothetical cases
> >> where it correctly predicts non-halting behavior.
> >
> > Since H has to give an answer within a finite time, it does indeed have to work out what *would* happen, rather than run the simulation all the way through. But it must simulate what the *actual* code would do,
> These machine code bytes do not change:
> 558bec518b4508508b4d0851e82ffdffff83c4088945fc837dfc007402ebfe8be55dc3
>
> The correct and complete simulation of a machine description is the
> definitive measure of the behavior of this machine description.
>
> When H performs a correct simulation of this finite string:
> 558bec518b4508508b4d0851e82ffdffff83c4088945fc837dfc007402ebfe8be55dc3
>
> an infinite behavior pattern is matched indicating that H must abort the
> simulation of this otherwise non-terminating input.
> > rather than what different code (ie code with a different H) would do.
> >
> >>> You are not claiming that H(PP,PP)==0 is stipulated to mean that Simulate(PP,PP) never halts?
> >>>
> >>> You are not claiming that H(PP,PP)==0 is stipulated to mean that PP(PP) never halts?
> >>>
> >>> You are not claiming that H is a halt decider?
> >>>
> >>> You are not claiming that H refutes the well-known proof that a halt decider cannot exist?

On 9/1/2022 2:41 PM, Paul N wrote:
> On Thursday, September 1, 2022 at 7:33:22 PM UTC+1, olcott wrote:
>> On 9/1/2022 1:15 PM, Paul N wrote:
>>> On Thursday, September 1, 2022 at 4:36:51 PM UTC+1, olcott wrote:
>>>> On 9/1/2022 10:19 AM, Paul N wrote:
>>>>> On Thursday, September 1, 2022 at 4:43:18 AM UTC+1, olcott wrote:
>>>>>> You are not going to be able to understand the next step until you
>>>>>> understand that the prior step is true.
>>>>>>
>>>>>> H(PP,PP)==0 is stipulated to mean that Simulate(Pz,Pz) never halts.
>>>>>
>>>>> Just to clarify, you are claiming that H(PP,PP)==0 is stipulated to mean that Simulate(Pz,Pz) never halts?
>>>>>
>>>> Simulate(Pz,Pz) is the way of encoding the correct and complete
>>>> simulation of the input H(P,P) by H.
>>>>
>>>> void P(ptr x)
>>>> {
>>>> int Halt_Status = H(x, x);
>>>> if (Halt_Status)
>>>> HERE: goto HERE;
>>>> return;
>>>> }
>>>>
>>>> We don't really need to change the name from P to Pz because P remains
>>>> this exact same machine language byte string:
>>>> 558bec518b4508508b4d0851e82ffdffff83c4088945fc837dfc007402ebfe8be55dc3
>>>>
>>>> H always bases its halt status decision on the behavior of the pure
>>>> simulation of its input as if H itself was a pure simulator and not a
>>>> halt decider.
>>>>
>>>> H0(Infinite_Loop) reports on the behavior of Simulate(Infinite_Loop)
>>>> *THE HYPOTHETICAL CASE WHERE H NEVER ABORTS ITS SIMULATION*
>>>
>>> These last two paragraphs are exactly the crux of the problem.
>>>
>>> The point is that P calls H. So if you change H, you are potentially changing the behaviour of P. So H is not reporting on the exact code it is considering, it is reporting on something else.
>>>
>> The decisive point is that P cannot possibly reach its own final state
>> thus conclusively proving that P never halts.
>
> But you have told us numerous times that P does in fact halt. Any "conclusive proof" that it doesn't is clearly wrong.
>
>>> As I said in another post, H is being asked to do an impossible job, which is why it fails to do it. You seem to think that P and H are just normal programs which, if you're careful enough, it ought to be possible to simulate and predict. You're too hooked up on the simulating bit, and you fail to notice that H's job is impossible.
>> That I wrote them in C and execute them proves that they are not mere
>> incorrect imaginings.
>>
>> In incorrect imagining is that any H must ever return a value to its
>> simulated P.
>>>
>>>> H(Infinite_Recursion, 0x777) reports on the behavior of
>>>> Simulate(H(Infinite_Recursion, 0x777)
>>>> *THE HYPOTHETICAL CASE WHERE H NEVER ABORTS ITS SIMULATION*
>>>>
>>>> H(P,P) reports on the behavior of:
>>>> void P(ptr x)
>>>> {
>>>> int Halt_Status = Simulate(x, x);
>>>> if (Halt_Status)
>>>> HERE: goto HERE;
>>>> return;
>>>> }
>>>> *THE HYPOTHETICAL CASE WHERE H NEVER ABORTS ITS SIMULATION*
>>>
>>> Exactly. You have just said, in capitals and with asterisks, that H is not reporting on what actually happens.
>> A simulating halt decider must always predict the behavior of its
>> correct and complete simulation of its input.
>>
>> H0(Infinite_Loop)
>> Reports that its correct and complete simulation of its input never
>> stops running.
>>
>> H(Infinite_Recursion, 0x777)
>> Reports that its correct and complete simulation of its input never
>> stops running.
>>
>> H(P, P)
>> Reports that its correct and complete simulation of its input never
>> stops running.
>
> Which is wrong, because P(P) halts and so a correct and complete simulation would also halt.

It is an easily verified fact when H(P,P) correctly simulates its input
that this simulated input would never stop running unless H aborts its
simulation of this input.

It is also an easily verified fact that halt deciders only compute the
mapping from finite string inputs to an accept or reject state.

It is also an easily verified fact that P(P) executed from main is not
an input to H(P,P).

int sum(int x, int y){ return x + y; }
Thus all of the "rebuttals" of my work have been essentially based on
the argument that sum(2,3) does not correctly derive the sum of 5 + 7.

--
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 Thu, 01 Sep 2022 19:08:17 +0100
Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:

> Mr Flibble <flibble@reddwarf.jmc.corp> writes:
>
> > On Thu, 01 Sep 2022 17:40:46 +0100
> > Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
> >
> >> Mr Flibble <flibble@reddwarf.jmc.corp> writes:
> >>
> >> > On Thu, 01 Sep 2022 17:05:54 +0100
> >> > Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
> >> >
> >> >> Mr Flibble <flibble@reddwarf.jmc.corp> writes:
> >> >>
> >> >> > On Thu, 1 Sep 2022 08:19:29 -0700 (PDT)
> >> >> > Paul N <gw7rib@aol.com> wrote:
> >> >> >
> >> >> >> You are not claiming that H refutes the well-known proof
> >> >> >> that a halt decider cannot exist?
> >> >> >
> >> >> > The well-known proof is the "Impossible Program" contradiction
> >> >> > and I have invented a halt decider that can detect that
> >> >> > contradiction ergo the Flibble Signaling Halt Decider (tm)
> >> >> > refutes that well-known proof.
> >> >>
> >> >> The well-known proof is about deciders. Not about functions
> >> >> that are not deciders. Not deciding is easy.
> >> >>
> >> >> Every time one teaches this material this "solution" comes up --
> >> >> just detect the "pathological" case and abort, or signal, or
> >> >> return a third result, or don't return at all, or... (the
> >> >> detail about how to avoid deciding vary).
> >> >
> >> > You are a liar: I am the first to invent a decider that can
> >> > detect the pathological case: prove me wrong.
> >>
> >> None of the students wrote papers about non-deciders so how could I
> >> prove that this comes up every time? But I will put my reputation
> >> for honesty here up against anyone. I don't lie.
> >
> > So you have failed to prove me wrong: I am the first to invent a
> > decider that can detect pathological input THAT WORKS.
>
> You are not. But neither claim can be easily proved. What is certain
> is that you do not have a decider.
>
> >> Of course, you could submit what you consider to be am entirely new
> >> idea to a journal and see what they say.
> >
> > I have already published my novel decider both in this forum and on
> > GitHub:
>
> I meant, as you know, somewhere that cares about quality. The journal
> editor will tell you it's not a new idea. They won't be able to prove
> it either (since it's trivial), but they won't publish it.
>
> >> What is indisputable is that what you call a decider is not a
> >> decider. A decider accepts or rejects every problem instance.
> >
> > What is indisputable is that pathological input neither halts nor
> > doesn't halt so not giving a decision of halt or doesn't halt IS THE
> > CORRECT THING TO DO.
>
> That is incorrect. It's wrong in several ways. First no input halts
> and no input does not halt. Halting is not an intrinsic property of
> inputs, but a property of the computations they represent. Second,
> all computations (in the sense of Strachey's letter) either halt or
> they don't. What do you think the "others" do?

If you want to play word games then fair enough: what is indisputable
is that a computation that represents a pathological input neither
halts nor doesn't halt so not giving a decision of halt or doesn't halt
IS THE CORRECT THING TO DO.

It might help your understanding if I elaborate a tad: a computation
that represents a pathological input is INVALID as it CANNOT EXIST
because it is referencing a halt decider that CANNOT EXIST UNLESS THAT
HALT DECIDER CAN DETECT THE PATHOLOGY.

It is a FACT therefore that the only valid halt decider is a halt
decider that can detect pathological inputs and report on them using a
signal: which is the halt decider that I have invented.

>
> As usual, by avoiding a formal model (like TMs, lambda calculus,
> combinator forms, etc) you introduce enough waffle to be able to boast
> about your achievement to your heart's content. That's pretty much
> what it's all about -- boasting.

I am not boasting: you are simply jealous that I have refuted the
primary halting problem proof by designing a halt decider that detects
pathological input.

/Flibble

On 9/1/22 10:31 AM, olcott wrote:
> On 9/1/2022 6:14 AM, Richard Damon wrote:
> >
> > On 8/31/22 11:43 PM, olcott wrote:
> >> On 8/31/2022 10:19 PM, Richard Damon wrote:
> >>> On 8/31/22 9:46 PM, olcott wrote:
> >>>> On 8/31/2022 8:41 PM, Richard Damon wrote:
> >>>>> On 8/31/22 9:29 PM, olcott wrote:
> >>>>>> On 8/31/2022 8:16 PM, Richard Damon wrote:
> >>>>>>> On 8/31/22 9:08 PM, olcott wrote:
> >>>>>>>> On 8/31/2022 8:04 PM, Richard Damon wrote:
> >>>>>>>>> On 8/31/22 8:54 PM, olcott wrote:
> >>>>>>>>>> On 8/31/2022 7:46 PM, Richard Damon wrote:
> >>>>>>>>>>>
> >>>>>>>>>>> On 8/31/22 8:24 PM, olcott wrote:
> >>>>>>>>>>>> On 8/31/2022 7:14 PM, Richard Damon wrote:
> >>>>>>>>>>>>> On 8/31/22 7:59 PM, olcott wrote:
> >>>>>>>>>>>>>> On 8/31/2022 6:49 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>> On 8/31/22 7:44 PM, olcott wrote:
> >>>>>>>>>>>>>>>> On 8/31/2022 6:04 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>> On 8/31/22 10:37 AM, olcott wrote:
> >>>>>>>>>>>>>>>>>> On 8/31/2022 5:58 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>> On 8/30/22 11:30 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>> On 8/30/2022 10:11 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>> On 8/30/22 10:51 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 9:22 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 10:12 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 9:01 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 9:53 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 8:44 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 9:35 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 8:19 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 8:52 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 7:40 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 7:46 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 5:37 PM, Richard Damon
> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IF Px REALLY does call Simulate,
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether it is the simulate you show
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (which doesn't actually simulates, but
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just calls its input), then Yes, THAT
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px is Non-Halting.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Great an honest reply. Now if H(P,P) was
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> supposed to predict the behavior of a
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete simulation of its
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input as if H was Simulate, then H(P,P)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would be correct return return 0.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You didn't read the rest.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H is supposed to predict whether or not
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a pure simulation of its input performed
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by Simulate (instead of H) will never stop
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running and H returns 0 then H is
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct no matter what process
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H uses to make this determination.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> But remember, P doesn't call simulate, it
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls H.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) correctly predicts that Simulate(x,y)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> never halts:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> H(ptr x, ptr y)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>    return 0;
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> But, assuming we are still talking about the
> >>>>>>>>>>>>>>>>>>>>>>>>>>> P that calls H(P,P), Simulate(P,P) does Halt
> >>>>>>>>>>>>>>>>>>>>>>>>>>> if H(P,P) return 0, so that answer is wrong.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> void Simulate(ptr x, ptr y)
> >>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>    x(y);
> >>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> void Pz(ptr x)
> >>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>    Simulate(x, x);
> >>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> If Fred is supposed to determine whether or
> >>>>>>>>>>>>>>>>>>>>>>>>>> not Simulate(Pz, Pz) halts:
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> u32 Fred()
> >>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>    return 0;
> >>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> *Then Fred is necessarily correct*
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> Right, H(Pz,Pz) is correct to say 0
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> void PP(ptr x)
> >>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>    H(x, x);
> >>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>    Output("Input_Halts = ", H(PP, PP));
> >>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> void Pz(ptr x)
> >>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>    Simulate(x, x);
> >>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> H(PP,PP) is correct to return 0 when returning 0
> >>>>>>>>>>>>>>>>>>>>>>>> means that Simulate(Pz,Pz) never halts.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> How are you justifying that H(PP,PP) is answering
> >>>>>>>>>>>>>>>>>>>>>>> about a TOTALLY DIFFERENT input Pz,Pz?
> >>>>>>>>>>>>>>>>>>>>>> Every function that returns 0 (interpreted as
> >>>>>>>>>>>>>>>>>>>>>> Boolean) is correctly answering: Does
> >>>>>>>>>>>>>>>>>>>>>> Simulate(Pz,Pz) halt?
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> If that is the question it is supposed to be
> >>>>>>>>>>>>>>>>>>>>> answering.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> So, your trying to claim victory by giving the
> >>>>>>>>>>>>>>>>>>>>> "right' answer to the worng question.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> I am not done yet.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> *We can move* *ON* *when you agree that this is true*
> >>>>>>>>>>>>>>>>>>>> H(PP,PP) is correct to return 0 when returning 0
> >>>>>>>>>>>>>>>>>>>> means that
> >>>>>>>>>>>>>>>>>>>> Simulate(Pz,Pz) never halts.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> So, you are stipulating that H isn't a halt decider.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> I am stipulating that H(PP,PP) is a halt decider for
> >>>>>>>>>>>>>>>>>> Simulate(Pz,Pz)
> >>>>>>>>>>>>>>>>>> Thus H(PP,PP)==0 is correct.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> What is Hz? did you mean Pz?
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Yes it was a typo.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> And how is it that? Since H hasn't been given anything
> >>>>>>>>>>>>>>>>> about Pz, so how can it be being asked about it.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> If when I say "there is a black cat sitting on my head"
> >>>>>>>>>>>>>>>> is code for 2 + 3 = 5, then "there is a black cat
> >>>>>>>>>>>>>>>> sitting on my head" is true.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> In this same way when I say that when H(PP,PP) returns 0
> >>>>>>>>>>>>>>>> this means that Simulate(Pz,Pz) never halts then
> >>>>>>>>>>>>>>>> H(PP,PP)==0 is correct.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> And things based on nonsense are just nonsense.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> You misdefine too many things to be allowed to play that
> >>>>>>>>>>>>>>> game.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> FAIL.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Being "Correct" means does what it is supposed to do.
> >>>>>>>>>>>>>>> Until you actually DEFINE how H is "correct" to do this,
> >>>>>>>>>>>>>>> you are just stating non-sense.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Remember, you aren't allowed to stipulate something is
> >>>>>>>>>>>>>>> correct.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> This is a mandatory prerequisite to the rest of my proof.
> >>>>>>>>>>>>>> I understand if you just want to disagree and don't want
> >>>>>>>>>>>>>> to understand.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> If it is a mandatory prerequisite, then your proof is
> invalid.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> If you can't explain the GROUNDS that H is using to be ABLE
> >>>>>>>>>>>>> to decide about Simulate(Pz,Pz) when given PP,PP, then your
> >>>>>>>>>>>>> logic is just broken.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> Because your only purpose is to be disagreeable I force the
> >>>>>>>>>>>> cost of a continuing dialogue to be mutual agreement at key
> >>>>>>>>>>>> points in the dialogue.
> >>>>>>>>>>>>
> >>>>>>>>>>>> I am unwilling to have any dialogue besides an honest
> >>>>>>>>>>>> dialogue. An honest dialogue require points of mutual
> >>>>>>>>>>>> agreement.
> >>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>
> >>>>>>>>>>> Right, so you need to explain HOW it is possible for H(PP,PP)
> >>>>>>>>>>> to be able to actually decide on Simulate(Pz,Pz).
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> *We must have have mutual agreement to proceed*
> >>>>>>>>>> *We must have have mutual agreement to proceed*
> >>>>>>>>>> *We must have have mutual agreement to proceed*
> >>>>>>>>>> *We must have have mutual agreement to proceed*
> >>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>
> >>>>>>>>> Yes, so answer my questions so we can agree.
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> *We must have have mutual agreement to proceed*
> >>>>>>>> *We must have have mutual agreement to proceed*
> >>>>>>>> *We must have have mutual agreement to proceed*
> >>>>>>>> *We must have have mutual agreement to proceed*
> >>>>>>>>
> >>>>>>>>
> >>>>>>>
> >>>>>>> So make the move to reach agreement. MUTUAL agreement isn't one
> way.
> >>>>>>
> >>>>>> *You must agree with my point or I will not move on to the next
> >>>>>> point*
> >>>>>>
> >>>>>>
> >>>>>
> >>>>> Nope, I've given my objection, and until you answer it, I will not
> >>>>> move on.
> >>>>
> >>>> You have not given any objection to the precise words that said and
> >>>> there is no correct objection to the precise words that I said
> >>>> because they are proven to be true entirely on the basis of their
> >>>> meaning.
> >>>>
> >>>> Not agreeing with words that are true on the basis of their meaning
> >>>> is a sign of dishonesty.
> >>>>
> >>>
> >>> No, I have objected to calling something a correct decider when the
> >>> thing it was deciding on was not given in any way as an input.
> >>
> >> You are not going to be able to understand the next step until you
> >> understand that the prior step is true.
> >>
> >> H(PP,PP)==0 is stipulated to mean that Simulate(Pz,Pz) never halts.
> >
> > You can't stipulate something which is illogical or can't exist.
> >
> When I stipulate "there is a what cat sitting on my head" is code for
> the meaning that 2+3=5 then, "there is a what cat sitting on my head" is
> true.
>

On 9/1/22 10:37 AM, olcott wrote:
> On 9/1/2022 6:22 AM, Richard Damon wrote:
>>
>> On 8/31/22 11:59 PM, olcott wrote:
>>> On 8/31/2022 10:19 PM, Richard Damon wrote:
>>>> On 8/31/22 9:46 PM, olcott wrote:
>>>>> On 8/31/2022 8:41 PM, Richard Damon wrote:
>>>>>> On 8/31/22 9:29 PM, olcott wrote:
>>>>>>> On 8/31/2022 8:16 PM, Richard Damon wrote:
>>>>>>>> On 8/31/22 9:08 PM, olcott wrote:
>>>>>>>>> On 8/31/2022 8:04 PM, Richard Damon wrote:
>>>>>>>>>> On 8/31/22 8:54 PM, olcott wrote:
>>>>>>>>>>> On 8/31/2022 7:46 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> On 8/31/22 8:24 PM, olcott wrote:
>>>>>>>>>>>>> On 8/31/2022 7:14 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 8/31/22 7:59 PM, olcott wrote:
>>>>>>>>>>>>>>> On 8/31/2022 6:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 8/31/22 7:44 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 8/31/2022 6:04 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 8/31/22 10:37 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 8/31/2022 5:58 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 8/30/22 11:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 10:11 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 10:51 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 9:22 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 10:12 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 9:01 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 9:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 8:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 9:35 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 8:19 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 8:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 7:40 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 7:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 5:37 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IF Px REALLY does call Simulate,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether it is the simulate you show
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (which doesn't actually simulates, but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just calls its input), then Yes, THAT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px is Non-Halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Great an honest reply. Now if H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> was supposed to predict the behavior of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a correct and complete simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input as if H was Simulate, then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) would be correct return return 0.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You didn't read the rest.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H is supposed to predict whether or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not a pure simulation of its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> performed by Simulate (instead of H) will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never stop running and H returns 0 then H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is necessarily correct no matter what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> process that H uses to make this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determination.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But remember, P doesn't call simulate, it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) correctly predicts that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulate(x,y) never halts:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>    return 0;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> But, assuming we are still talking about the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> P that calls H(P,P), Simulate(P,P) does Halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>> if H(P,P) return 0, so that answer is wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> void Simulate(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>    x(y);
>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> void Pz(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>    Simulate(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> If Fred is supposed to determine whether or
>>>>>>>>>>>>>>>>>>>>>>>>>>> not Simulate(Pz, Pz) halts:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> u32 Fred()
>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>    return 0;
>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> *Then Fred is necessarily correct*
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Right, H(Pz,Pz) is correct to say 0
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> void PP(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>    H(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>    Output("Input_Halts = ", H(PP, PP));
>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> void Pz(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>    Simulate(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> H(PP,PP) is correct to return 0 when returning
>>>>>>>>>>>>>>>>>>>>>>>>> 0 means that Simulate(Pz,Pz) never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> How are you justifying that H(PP,PP) is
>>>>>>>>>>>>>>>>>>>>>>>> answering about a TOTALLY DIFFERENT input Pz,Pz?
>>>>>>>>>>>>>>>>>>>>>>> Every function that returns 0 (interpreted as
>>>>>>>>>>>>>>>>>>>>>>> Boolean) is correctly answering: Does
>>>>>>>>>>>>>>>>>>>>>>> Simulate(Pz,Pz) halt?
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> If that is the question it is supposed to be
>>>>>>>>>>>>>>>>>>>>>> answering.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> So, your trying to claim victory by giving the
>>>>>>>>>>>>>>>>>>>>>> "right' answer to the worng question.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> I am not done yet.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *We can move* *ON* *when you agree that this is true*
>>>>>>>>>>>>>>>>>>>>> H(PP,PP) is correct to return 0 when returning 0
>>>>>>>>>>>>>>>>>>>>> means that
>>>>>>>>>>>>>>>>>>>>> Simulate(Pz,Pz) never halts.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> So, you are stipulating that H isn't a halt decider.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I am stipulating that H(PP,PP) is a halt decider for
>>>>>>>>>>>>>>>>>>> Simulate(Pz,Pz)
>>>>>>>>>>>>>>>>>>> Thus H(PP,PP)==0 is correct.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> What is Hz? did you mean Pz?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Yes it was a typo.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> And how is it that? Since H hasn't been given anything
>>>>>>>>>>>>>>>>>> about Pz, so how can it be being asked about it.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If when I say "there is a black cat sitting on my head"
>>>>>>>>>>>>>>>>> is code for 2 + 3 = 5, then "there is a black cat
>>>>>>>>>>>>>>>>> sitting on my head" is true.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> In this same way when I say that when H(PP,PP) returns
>>>>>>>>>>>>>>>>> 0 this means that Simulate(Pz,Pz) never halts then
>>>>>>>>>>>>>>>>> H(PP,PP)==0 is correct.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> And things based on nonsense are just nonsense.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You misdefine too many things to be allowed to play that
>>>>>>>>>>>>>>>> game.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Being "Correct" means does what it is supposed to do.
>>>>>>>>>>>>>>>> Until you actually DEFINE how H is "correct" to do this,
>>>>>>>>>>>>>>>> you are just stating non-sense.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Remember, you aren't allowed to stipulate something is
>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> This is a mandatory prerequisite to the rest of my proof.
>>>>>>>>>>>>>>> I understand if you just want to disagree and don't want
>>>>>>>>>>>>>>> to understand.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If it is a mandatory prerequisite, then your proof is
>>>>>>>>>>>>>> invalid.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If you can't explain the GROUNDS that H is using to be
>>>>>>>>>>>>>> ABLE to decide about Simulate(Pz,Pz) when given PP,PP,
>>>>>>>>>>>>>> then your logic is just broken.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Because your only purpose is to be disagreeable I force the
>>>>>>>>>>>>> cost of a continuing dialogue to be mutual agreement at key
>>>>>>>>>>>>> points in the dialogue.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I am unwilling to have any dialogue besides an honest
>>>>>>>>>>>>> dialogue. An honest dialogue require points of mutual
>>>>>>>>>>>>> agreement.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Right, so you need to explain HOW it is possible for
>>>>>>>>>>>> H(PP,PP) to be able to actually decide on Simulate(Pz,Pz).
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Yes, so answer my questions so we can agree.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> So make the move to reach agreement. MUTUAL agreement isn't one
>>>>>>>> way.
>>>>>>>
>>>>>>> *You must agree with my point or I will not move on to the next
>>>>>>> point*
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Nope, I've given my objection, and until you answer it, I will not
>>>>>> move on.
>>>>>
>>>>> You have not given any objection to the precise words that said and
>>>>> there is no correct objection to the precise words that I said
>>>>> because they are proven to be true entirely on the basis of their
>>>>> meaning.
>>>>>
>>>>> Not agreeing with words that are true on the basis of their meaning
>>>>> is a sign of dishonesty.
>>>>>
>>>>
>>>> No, I have objected to calling something a correct decider when the
>>>> thing it was deciding on was not given in any way as an input.
>>>>
>>> The correct behavior of H is stipulated to be correctly determining
>>> whether or not it must abort the simulation of its input to prevent
>>> the otherwise infinite execution of this input.
>>>
>>
>> Then H is stipulated to not be a Halt Decider based on your definition
>> of this.
>>
>>> That H must abort the simulation of its input to prevent the infinite
>>> execution of this input is another way of saying that this input
>>> never stops running.
>>>
>>>
>>
>> Nope. Since you are changing the GLOBAL definition H, and not just the
>> instance to do your test case, you logic is invalid.
> It is stipulated that input the never stops running unless its
> simulation is aborted is input that never stops running.

On 9/1/22 10:59 AM, olcott wrote:
> On 9/1/2022 6:22 AM, Richard Damon wrote:
>>
>> On 8/31/22 11:59 PM, olcott wrote:
>>> On 8/31/2022 10:19 PM, Richard Damon wrote:
>>>> On 8/31/22 9:46 PM, olcott wrote:
>>>>> On 8/31/2022 8:41 PM, Richard Damon wrote:
>>>>>> On 8/31/22 9:29 PM, olcott wrote:
>>>>>>> On 8/31/2022 8:16 PM, Richard Damon wrote:
>>>>>>>> On 8/31/22 9:08 PM, olcott wrote:
>>>>>>>>> On 8/31/2022 8:04 PM, Richard Damon wrote:
>>>>>>>>>> On 8/31/22 8:54 PM, olcott wrote:
>>>>>>>>>>> On 8/31/2022 7:46 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> On 8/31/22 8:24 PM, olcott wrote:
>>>>>>>>>>>>> On 8/31/2022 7:14 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 8/31/22 7:59 PM, olcott wrote:
>>>>>>>>>>>>>>> On 8/31/2022 6:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 8/31/22 7:44 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 8/31/2022 6:04 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 8/31/22 10:37 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 8/31/2022 5:58 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 8/30/22 11:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 10:11 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 10:51 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 9:22 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 10:12 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 9:01 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 9:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 8:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 9:35 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 8:19 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 8:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 7:40 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 7:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 5:37 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IF Px REALLY does call Simulate,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether it is the simulate you show
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (which doesn't actually simulates, but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just calls its input), then Yes, THAT
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Px is Non-Halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Great an honest reply. Now if H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> was supposed to predict the behavior of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a correct and complete simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input as if H was Simulate, then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) would be correct return return 0.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You didn't read the rest.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H is supposed to predict whether or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not a pure simulation of its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> performed by Simulate (instead of H) will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never stop running and H returns 0 then H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is necessarily correct no matter what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> process that H uses to make this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determination.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But remember, P doesn't call simulate, it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) correctly predicts that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulate(x,y) never halts:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>    return 0;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> But, assuming we are still talking about the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> P that calls H(P,P), Simulate(P,P) does Halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>> if H(P,P) return 0, so that answer is wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> void Simulate(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>    x(y);
>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> void Pz(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>    Simulate(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> If Fred is supposed to determine whether or
>>>>>>>>>>>>>>>>>>>>>>>>>>> not Simulate(Pz, Pz) halts:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> u32 Fred()
>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>    return 0;
>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> *Then Fred is necessarily correct*
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Right, H(Pz,Pz) is correct to say 0
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> void PP(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>    H(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>    Output("Input_Halts = ", H(PP, PP));
>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> void Pz(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>    Simulate(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> H(PP,PP) is correct to return 0 when returning
>>>>>>>>>>>>>>>>>>>>>>>>> 0 means that Simulate(Pz,Pz) never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> How are you justifying that H(PP,PP) is
>>>>>>>>>>>>>>>>>>>>>>>> answering about a TOTALLY DIFFERENT input Pz,Pz?
>>>>>>>>>>>>>>>>>>>>>>> Every function that returns 0 (interpreted as
>>>>>>>>>>>>>>>>>>>>>>> Boolean) is correctly answering: Does
>>>>>>>>>>>>>>>>>>>>>>> Simulate(Pz,Pz) halt?
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> If that is the question it is supposed to be
>>>>>>>>>>>>>>>>>>>>>> answering.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> So, your trying to claim victory by giving the
>>>>>>>>>>>>>>>>>>>>>> "right' answer to the worng question.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> I am not done yet.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *We can move* *ON* *when you agree that this is true*
>>>>>>>>>>>>>>>>>>>>> H(PP,PP) is correct to return 0 when returning 0
>>>>>>>>>>>>>>>>>>>>> means that
>>>>>>>>>>>>>>>>>>>>> Simulate(Pz,Pz) never halts.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> So, you are stipulating that H isn't a halt decider.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I am stipulating that H(PP,PP) is a halt decider for
>>>>>>>>>>>>>>>>>>> Simulate(Pz,Pz)
>>>>>>>>>>>>>>>>>>> Thus H(PP,PP)==0 is correct.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> What is Hz? did you mean Pz?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Yes it was a typo.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> And how is it that? Since H hasn't been given anything
>>>>>>>>>>>>>>>>>> about Pz, so how can it be being asked about it.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If when I say "there is a black cat sitting on my head"
>>>>>>>>>>>>>>>>> is code for 2 + 3 = 5, then "there is a black cat
>>>>>>>>>>>>>>>>> sitting on my head" is true.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> In this same way when I say that when H(PP,PP) returns
>>>>>>>>>>>>>>>>> 0 this means that Simulate(Pz,Pz) never halts then
>>>>>>>>>>>>>>>>> H(PP,PP)==0 is correct.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> And things based on nonsense are just nonsense.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You misdefine too many things to be allowed to play that
>>>>>>>>>>>>>>>> game.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Being "Correct" means does what it is supposed to do.
>>>>>>>>>>>>>>>> Until you actually DEFINE how H is "correct" to do this,
>>>>>>>>>>>>>>>> you are just stating non-sense.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Remember, you aren't allowed to stipulate something is
>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> This is a mandatory prerequisite to the rest of my proof.
>>>>>>>>>>>>>>> I understand if you just want to disagree and don't want
>>>>>>>>>>>>>>> to understand.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If it is a mandatory prerequisite, then your proof is
>>>>>>>>>>>>>> invalid.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If you can't explain the GROUNDS that H is using to be
>>>>>>>>>>>>>> ABLE to decide about Simulate(Pz,Pz) when given PP,PP,
>>>>>>>>>>>>>> then your logic is just broken.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Because your only purpose is to be disagreeable I force the
>>>>>>>>>>>>> cost of a continuing dialogue to be mutual agreement at key
>>>>>>>>>>>>> points in the dialogue.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I am unwilling to have any dialogue besides an honest
>>>>>>>>>>>>> dialogue. An honest dialogue require points of mutual
>>>>>>>>>>>>> agreement.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Right, so you need to explain HOW it is possible for
>>>>>>>>>>>> H(PP,PP) to be able to actually decide on Simulate(Pz,Pz).
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Yes, so answer my questions so we can agree.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> So make the move to reach agreement. MUTUAL agreement isn't one
>>>>>>>> way.
>>>>>>>
>>>>>>> *You must agree with my point or I will not move on to the next
>>>>>>> point*
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Nope, I've given my objection, and until you answer it, I will not
>>>>>> move on.
>>>>>
>>>>> You have not given any objection to the precise words that said and
>>>>> there is no correct objection to the precise words that I said
>>>>> because they are proven to be true entirely on the basis of their
>>>>> meaning.
>>>>>
>>>>> Not agreeing with words that are true on the basis of their meaning
>>>>> is a sign of dishonesty.
>>>>>
>>>>
>>>> No, I have objected to calling something a correct decider when the
>>>> thing it was deciding on was not given in any way as an input.
>>>>
>>> The correct behavior of H is stipulated to be correctly determining
>>> whether or not it must abort the simulation of its input to prevent
>>> the otherwise infinite execution of this input.
>>>
>>
>> Then H is stipulated to not be a Halt Decider based on your definition
>> of this.
>>
>>> That H must abort the simulation of its input to prevent the infinite
>>> execution of this input is another way of saying that this input
>>> never stops running.
>>>
>>>
>>
>> Nope. Since you are changing the GLOBAL definition H, and not just the
>> instance to do your test case, you logic is invalid.
>>
>> This has been explained to you many times, and you failure to correct
>> your statements shows that either you are a pathological liar that
>> doesn't care about what is actually true, or you are just totally
>> ignorant about the subject, or both (that latter most likely in my case).
>>
>> The fact that you say this must be true, but when showed the ACTUAL
>> BEHAVIOR of that input you still hold to your idea says that you are
>> not being honest. The error in your definition is clear because P(P)
>> Halts when H(P,P) returns 0, so the fact that some other Hn that who
>> is different from this H because it doesn't include the abort, and the
>> Pn that is built form that Hn, create an infinite recursion, CAN'T
>> correctly define the halting of the P that we have here.
>>
>> FAIL.
>>
>> That is like you having a pet snake that you call your pet cat, but
>> when someone points out that your pet snake can't be a cat because it
>> doesn't have legs and fur, you just reply that not all cats have legs
>> and fur, so you are going to keep treating you snake as a cat.
>
>
> THE MEANING OF THESE WORDS PROVE THAT THEY ARE TRUE
>
> When-so-ever the input/argument to a simulating halt decider (SHD) would
> never stop running unless its simulation was aborted is merely another
> way of saying that this input never reaches its final state and halts.
>

On 9/1/2022 5:52 PM, Richard Damon wrote:
> On 9/1/22 10:37 AM, olcott wrote:
>> On 9/1/2022 6:22 AM, Richard Damon wrote:
>>>
>>> On 8/31/22 11:59 PM, olcott wrote:
>>>> On 8/31/2022 10:19 PM, Richard Damon wrote:
>>>>> On 8/31/22 9:46 PM, olcott wrote:
>>>>>> On 8/31/2022 8:41 PM, Richard Damon wrote:
>>>>>>> On 8/31/22 9:29 PM, olcott wrote:
>>>>>>>> On 8/31/2022 8:16 PM, Richard Damon wrote:
>>>>>>>>> On 8/31/22 9:08 PM, olcott wrote:
>>>>>>>>>> On 8/31/2022 8:04 PM, Richard Damon wrote:
>>>>>>>>>>> On 8/31/22 8:54 PM, olcott wrote:
>>>>>>>>>>>> On 8/31/2022 7:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> On 8/31/22 8:24 PM, olcott wrote:
>>>>>>>>>>>>>> On 8/31/2022 7:14 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 8/31/22 7:59 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 8/31/2022 6:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 8/31/22 7:44 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 8/31/2022 6:04 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 8/31/22 10:37 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 8/31/2022 5:58 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 8/30/22 11:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 10:11 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 10:51 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 9:22 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 10:12 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 9:01 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 9:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 8:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 9:35 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 8:19 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 8:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 7:40 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 7:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 5:37 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IF Px REALLY does call Simulate,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether it is the simulate you show
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (which doesn't actually simulates,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but just calls its input), then Yes,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THAT Px is Non-Halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Great an honest reply. Now if H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> was supposed to predict the behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of a correct and complete simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input as if H was Simulate,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then H(P,P) would be correct return
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return 0.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You didn't read the rest.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H is supposed to predict whether or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not a pure simulation of its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> performed by Simulate (instead of H)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will never stop running and H returns 0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then H is necessarily correct no matter
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what process that H uses to make this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determination.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But remember, P doesn't call simulate, it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) correctly predicts that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulate(x,y) never halts:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>    return 0;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But, assuming we are still talking about
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the P that calls H(P,P), Simulate(P,P) does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halt if H(P,P) return 0, so that answer is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> void Simulate(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>    x(y);
>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> void Pz(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>    Simulate(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> If Fred is supposed to determine whether or
>>>>>>>>>>>>>>>>>>>>>>>>>>>> not Simulate(Pz, Pz) halts:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> u32 Fred()
>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>    return 0;
>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Then Fred is necessarily correct*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, H(Pz,Pz) is correct to say 0
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> void PP(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>    H(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>    Output("Input_Halts = ", H(PP, PP));
>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> void Pz(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>    Simulate(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> H(PP,PP) is correct to return 0 when returning
>>>>>>>>>>>>>>>>>>>>>>>>>> 0 means that Simulate(Pz,Pz) never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> How are you justifying that H(PP,PP) is
>>>>>>>>>>>>>>>>>>>>>>>>> answering about a TOTALLY DIFFERENT input Pz,Pz?
>>>>>>>>>>>>>>>>>>>>>>>> Every function that returns 0 (interpreted as
>>>>>>>>>>>>>>>>>>>>>>>> Boolean) is correctly answering: Does
>>>>>>>>>>>>>>>>>>>>>>>> Simulate(Pz,Pz) halt?
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> If that is the question it is supposed to be
>>>>>>>>>>>>>>>>>>>>>>> answering.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> So, your trying to claim victory by giving the
>>>>>>>>>>>>>>>>>>>>>>> "right' answer to the worng question.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> I am not done yet.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *We can move* *ON* *when you agree that this is true*
>>>>>>>>>>>>>>>>>>>>>> H(PP,PP) is correct to return 0 when returning 0
>>>>>>>>>>>>>>>>>>>>>> means that
>>>>>>>>>>>>>>>>>>>>>> Simulate(Pz,Pz) never halts.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> So, you are stipulating that H isn't a halt decider.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> I am stipulating that H(PP,PP) is a halt decider for
>>>>>>>>>>>>>>>>>>>> Simulate(Pz,Pz)
>>>>>>>>>>>>>>>>>>>> Thus H(PP,PP)==0 is correct.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> What is Hz? did you mean Pz?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Yes it was a typo.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> And how is it that? Since H hasn't been given
>>>>>>>>>>>>>>>>>>> anything about Pz, so how can it be being asked about
>>>>>>>>>>>>>>>>>>> it.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If when I say "there is a black cat sitting on my
>>>>>>>>>>>>>>>>>> head" is code for 2 + 3 = 5, then "there is a black
>>>>>>>>>>>>>>>>>> cat sitting on my head" is true.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> In this same way when I say that when H(PP,PP) returns
>>>>>>>>>>>>>>>>>> 0 this means that Simulate(Pz,Pz) never halts then
>>>>>>>>>>>>>>>>>> H(PP,PP)==0 is correct.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> And things based on nonsense are just nonsense.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You misdefine too many things to be allowed to play
>>>>>>>>>>>>>>>>> that game.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Being "Correct" means does what it is supposed to do.
>>>>>>>>>>>>>>>>> Until you actually DEFINE how H is "correct" to do
>>>>>>>>>>>>>>>>> this, you are just stating non-sense.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Remember, you aren't allowed to stipulate something is
>>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> This is a mandatory prerequisite to the rest of my proof.
>>>>>>>>>>>>>>>> I understand if you just want to disagree and don't want
>>>>>>>>>>>>>>>> to understand.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If it is a mandatory prerequisite, then your proof is
>>>>>>>>>>>>>>> invalid.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If you can't explain the GROUNDS that H is using to be
>>>>>>>>>>>>>>> ABLE to decide about Simulate(Pz,Pz) when given PP,PP,
>>>>>>>>>>>>>>> then your logic is just broken.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Because your only purpose is to be disagreeable I force
>>>>>>>>>>>>>> the cost of a continuing dialogue to be mutual agreement
>>>>>>>>>>>>>> at key points in the dialogue.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I am unwilling to have any dialogue besides an honest
>>>>>>>>>>>>>> dialogue. An honest dialogue require points of mutual
>>>>>>>>>>>>>> agreement.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Right, so you need to explain HOW it is possible for
>>>>>>>>>>>>> H(PP,PP) to be able to actually decide on Simulate(Pz,Pz).
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Yes, so answer my questions so we can agree.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> So make the move to reach agreement. MUTUAL agreement isn't one
>>>>>>>>> way.
>>>>>>>>
>>>>>>>> *You must agree with my point or I will not move on to the next
>>>>>>>> point*
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Nope, I've given my objection, and until you answer it, I will
>>>>>>> not move on.
>>>>>>
>>>>>> You have not given any objection to the precise words that said
>>>>>> and there is no correct objection to the precise words that I said
>>>>>> because they are proven to be true entirely on the basis of their
>>>>>> meaning.
>>>>>>
>>>>>> Not agreeing with words that are true on the basis of their
>>>>>> meaning is a sign of dishonesty.
>>>>>>
>>>>>
>>>>> No, I have objected to calling something a correct decider when the
>>>>> thing it was deciding on was not given in any way as an input.
>>>>>
>>>> The correct behavior of H is stipulated to be correctly determining
>>>> whether or not it must abort the simulation of its input to prevent
>>>> the otherwise infinite execution of this input.
>>>>
>>>
>>> Then H is stipulated to not be a Halt Decider based on your
>>> definition of this.
>>>
>>>> That H must abort the simulation of its input to prevent the
>>>> infinite execution of this input is another way of saying that this
>>>> input never stops running.
>>>>
>>>>
>>>
>>> Nope. Since you are changing the GLOBAL definition H, and not just
>>> the instance to do your test case, you logic is invalid.
>> It is stipulated that input the never stops running unless its
>> simulation is aborted is input that never stops running.
>
> Depends on the exact meaning you give those words.
>
>>
>> It is common knowledge that deciders map their finite string
>> inputs/arguments to an accept or reject state thus conclusively
>> proving that the behavior of P(P) is totally irrelevant to H because
>> P(P) is not an input/argument to H.
>>
>>
>
> Nope, The finite string input to H(P,P) is the representation of P(P),

Mr Flibble <flibble@reddwarf.jmc.corp> writes:

> On Thu, 01 Sep 2022 19:08:17 +0100
> Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
>
>> Mr Flibble <flibble@reddwarf.jmc.corp> writes:
>>
>> > On Thu, 01 Sep 2022 17:40:46 +0100
>> > Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
>> >
>> >> Mr Flibble <flibble@reddwarf.jmc.corp> writes:
>> >>
>> >> > On Thu, 01 Sep 2022 17:05:54 +0100
>> >> > Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
>> >> >
>> >> >> Mr Flibble <flibble@reddwarf.jmc.corp> writes:
>> >> >>
>> >> >> > On Thu, 1 Sep 2022 08:19:29 -0700 (PDT)
>> >> >> > Paul N <gw7rib@aol.com> wrote:
>> >> >> >
>> >> >> >> You are not claiming that H refutes the well-known proof
>> >> >> >> that a halt decider cannot exist?
>> >> >> >
>> >> >> > The well-known proof is the "Impossible Program" contradiction
>> >> >> > and I have invented a halt decider that can detect that
>> >> >> > contradiction ergo the Flibble Signaling Halt Decider (tm)
>> >> >> > refutes that well-known proof.
>> >> >>
>> >> >> The well-known proof is about deciders. Not about functions
>> >> >> that are not deciders. Not deciding is easy.
>> >> >>
>> >> >> Every time one teaches this material this "solution" comes up --
>> >> >> just detect the "pathological" case and abort, or signal, or
>> >> >> return a third result, or don't return at all, or... (the
>> >> >> detail about how to avoid deciding vary).
>> >> >
>> >> > You are a liar: I am the first to invent a decider that can
>> >> > detect the pathological case: prove me wrong.
>> >>
>> >> None of the students wrote papers about non-deciders so how could I
>> >> prove that this comes up every time? But I will put my reputation
>> >> for honesty here up against anyone. I don't lie.
>> >
>> > So you have failed to prove me wrong: I am the first to invent a
>> > decider that can detect pathological input THAT WORKS.
>>
>> You are not. But neither claim can be easily proved. What is certain
>> is that you do not have a decider.
>>
>> >> Of course, you could submit what you consider to be am entirely new
>> >> idea to a journal and see what they say.
>> >
>> > I have already published my novel decider both in this forum and on
>> > GitHub:
>>
>> I meant, as you know, somewhere that cares about quality. The journal
>> editor will tell you it's not a new idea. They won't be able to prove
>> it either (since it's trivial), but they won't publish it.
>>
>> >> What is indisputable is that what you call a decider is not a
>> >> decider. A decider accepts or rejects every problem instance.
>> >
>> > What is indisputable is that pathological input neither halts nor
>> > doesn't halt so not giving a decision of halt or doesn't halt IS THE
>> > CORRECT THING TO DO.
>>
>> That is incorrect. It's wrong in several ways. First no input halts
>> and no input does not halt. Halting is not an intrinsic property of
>> inputs, but a property of the computations they represent. Second,
>> all computations (in the sense of Strachey's letter) either halt or
>> they don't. What do you think the "others" do?
>
> If you want to play word games then fair enough:

No, no, no. I don't want more words from you. I used words rather than
anything formal because your claim is not based on any formal model but
I'd much rather ditch the piles of words.

Most people who have "solved the halting problem" have never read a
proper proof of the theorem. They've read a summary of an informal
argument, but it seems you would rather be more precise. So what model
do you want to work with? TMs? Lambda calculus? Combinator forms?

> what is indisputable
> is that a computation that represents a pathological input neither
> halts nor doesn't halt so not giving a decision of halt or doesn't halt
> IS THE CORRECT THING TO DO.

There is no known model of computation that has a third option. A TM
halts or it does not. A lambda form reduces to a normal form or it does
not. What model do you have in mind that does neither?

> It might help your understanding if I elaborate a tad: a computation
> that represents a pathological input is INVALID as it CANNOT EXIST
> because it is referencing a halt decider that CANNOT EXIST UNLESS THAT
> HALT DECIDER CAN DETECT THE PATHOLOGY.

This is exactly why I don't like word waffle. Computations don't
represent inputs, inputs represent computations, so I am stuck right
away. Something does not exist, but what? There is no such thing as a
non-existent computation (when the term is properly defined), and a
non-existent input is even more daft.

Let me set out one way to think about this clearly. A computation is
the sequence of configurations (sate + tape) generated by a TM's state
transition function. It's simplest to consider just a blank initial
tape so there is no input to worry about. A computation "halts" if that
sequence is finite and it "does not halt" otherwise. We can be loose
and call the TM a computation, but it's actually the generated sequence
that is either finite or not.

We can also fix the alphabet to be, say blank, 0 and 1, and we can use
numbers for the states so that a computation (well, the TM that
generates the computation) just depends on the state transition
function. These can be ordered using the usual lexicographic ordering
for lists of tuples.

Thus there is a first TM, a second TM and so. A halt decider is a TM
that takes, on it's tape, a number, n, in binary and accepts or rejects
depending on whether the nth TM halts given a blank initial tape. This
is a very stripped-down model, but even here there is no TM that can do
this.

Note that there is no waffling about a computation representing inputs
that don't exist (whatever that means). Every binary number denotes a
computation (the nth in the sequence of possible state transition
functions) and that state transition function either produces a finite
computation or it does not.

You may choose to call some numbers "pathological", but the numbers
exist, the input exists (the binary digits of that number) and the TM so
numbered by the input exists.

> It is a FACT therefore that the only valid halt decider is a halt
> decider that can detect pathological inputs and report on them using a
> signal: which is the halt decider that I have invented.

If the input that results in a signal represents a computation, then
that signal is not a valid answer, and is what every year comes up in
class -- detect that the input is of the "self-referential" form
presented in the proof and abort (or signal, or whatever).

If the input that results in a signal is not a computation then it makes
no difference what you do. A halt decider only has to answer correctly
about computations that exist -- program that can actually be written.
A TM with any finite state transition function.

I can't decode the word salad to know which is the case, but both are
wrong.

>> As usual, by avoiding a formal model (like TMs, lambda calculus,
>> combinator forms, etc) you introduce enough waffle to be able to boast
>> about your achievement to your heart's content. That's pretty much
>> what it's all about -- boasting.
>
> I am not boasting:

Of course you are. Empty boasting. There's no formal model, no proof,
no published paper... Just grandiose claims. It's textbook boasting.
It's as if someone said that they have a universal compiler that can
compile any programming language with no supporting evidence.

> you are simply jealous that I have refuted the primary halting problem
> proof by designing a halt decider that detects pathological input.

As far as I can tell, in your informal model, every input either
represents a halting computation, a non-halting computation or something
else (some sort of non computation -- it's not exactly clear). A halt
decider only cares about the first two. It's irrelevant what it might
do with inputs that don't represent either a halting computation or a
non-halting computation. If you "signal" only the third category, you
are actually claiming to have a conventional halt decider because the
other inputs are irrelevant. And if you "signal" any of the first two
kinds of input you don't have a decider at all.

On 9/1/22 8:18 PM, olcott wrote:
> On 9/1/2022 5:52 PM, Richard Damon wrote:
>> On 9/1/22 10:37 AM, olcott wrote:
>>> On 9/1/2022 6:22 AM, Richard Damon wrote:
>>>>
>>>> On 8/31/22 11:59 PM, olcott wrote:
>>>>> On 8/31/2022 10:19 PM, Richard Damon wrote:
>>>>>> On 8/31/22 9:46 PM, olcott wrote:
>>>>>>> On 8/31/2022 8:41 PM, Richard Damon wrote:
>>>>>>>> On 8/31/22 9:29 PM, olcott wrote:
>>>>>>>>> On 8/31/2022 8:16 PM, Richard Damon wrote:
>>>>>>>>>> On 8/31/22 9:08 PM, olcott wrote:
>>>>>>>>>>> On 8/31/2022 8:04 PM, Richard Damon wrote:
>>>>>>>>>>>> On 8/31/22 8:54 PM, olcott wrote:
>>>>>>>>>>>>> On 8/31/2022 7:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 8/31/22 8:24 PM, olcott wrote:
>>>>>>>>>>>>>>> On 8/31/2022 7:14 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 8/31/22 7:59 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 8/31/2022 6:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 8/31/22 7:44 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 8/31/2022 6:04 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 8/31/22 10:37 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 8/31/2022 5:58 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 11:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 10:11 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 10:51 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 9:22 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 10:12 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 9:01 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 9:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 8:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 9:35 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 8:19 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 8:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 7:40 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 7:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 5:37 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IF Px REALLY does call Simulate,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether it is the simulate you show
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (which doesn't actually simulates,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but just calls its input), then Yes,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THAT Px is Non-Halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Great an honest reply. Now if H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> was supposed to predict the behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of a correct and complete simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input as if H was Simulate,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then H(P,P) would be correct return
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return 0.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You didn't read the rest.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H is supposed to predict whether or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not a pure simulation of its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> performed by Simulate (instead of H)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will never stop running and H returns 0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then H is necessarily correct no matter
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what process that H uses to make this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determination.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But remember, P doesn't call simulate,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it calls H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) correctly predicts that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulate(x,y) never halts:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>    return 0;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But, assuming we are still talking about
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the P that calls H(P,P), Simulate(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does Halt if H(P,P) return 0, so that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer is wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void Simulate(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>    x(y);
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void Pz(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>    Simulate(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If Fred is supposed to determine whether or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not Simulate(Pz, Pz) halts:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> u32 Fred()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>    return 0;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Then Fred is necessarily correct*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, H(Pz,Pz) is correct to say 0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> void PP(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>    H(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>    Output("Input_Halts = ", H(PP, PP));
>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> void Pz(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>    Simulate(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> H(PP,PP) is correct to return 0 when
>>>>>>>>>>>>>>>>>>>>>>>>>>> returning 0 means that Simulate(Pz,Pz) never
>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> How are you justifying that H(PP,PP) is
>>>>>>>>>>>>>>>>>>>>>>>>>> answering about a TOTALLY DIFFERENT input Pz,Pz?
>>>>>>>>>>>>>>>>>>>>>>>>> Every function that returns 0 (interpreted as
>>>>>>>>>>>>>>>>>>>>>>>>> Boolean) is correctly answering: Does
>>>>>>>>>>>>>>>>>>>>>>>>> Simulate(Pz,Pz) halt?
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> If that is the question it is supposed to be
>>>>>>>>>>>>>>>>>>>>>>>> answering.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> So, your trying to claim victory by giving the
>>>>>>>>>>>>>>>>>>>>>>>> "right' answer to the worng question.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> I am not done yet.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *We can move* *ON* *when you agree that this is
>>>>>>>>>>>>>>>>>>>>>>> true*
>>>>>>>>>>>>>>>>>>>>>>> H(PP,PP) is correct to return 0 when returning 0
>>>>>>>>>>>>>>>>>>>>>>> means that
>>>>>>>>>>>>>>>>>>>>>>> Simulate(Pz,Pz) never halts.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> So, you are stipulating that H isn't a halt decider.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> I am stipulating that H(PP,PP) is a halt decider
>>>>>>>>>>>>>>>>>>>>> for Simulate(Pz,Pz)
>>>>>>>>>>>>>>>>>>>>> Thus H(PP,PP)==0 is correct.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> What is Hz? did you mean Pz?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Yes it was a typo.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> And how is it that? Since H hasn't been given
>>>>>>>>>>>>>>>>>>>> anything about Pz, so how can it be being asked
>>>>>>>>>>>>>>>>>>>> about it.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If when I say "there is a black cat sitting on my
>>>>>>>>>>>>>>>>>>> head" is code for 2 + 3 = 5, then "there is a black
>>>>>>>>>>>>>>>>>>> cat sitting on my head" is true.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> In this same way when I say that when H(PP,PP)
>>>>>>>>>>>>>>>>>>> returns 0 this means that Simulate(Pz,Pz) never halts
>>>>>>>>>>>>>>>>>>> then H(PP,PP)==0 is correct.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> And things based on nonsense are just nonsense.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You misdefine too many things to be allowed to play
>>>>>>>>>>>>>>>>>> that game.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Being "Correct" means does what it is supposed to do.
>>>>>>>>>>>>>>>>>> Until you actually DEFINE how H is "correct" to do
>>>>>>>>>>>>>>>>>> this, you are just stating non-sense.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Remember, you aren't allowed to stipulate something is
>>>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> This is a mandatory prerequisite to the rest of my proof.
>>>>>>>>>>>>>>>>> I understand if you just want to disagree and don't
>>>>>>>>>>>>>>>>> want to understand.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If it is a mandatory prerequisite, then your proof is
>>>>>>>>>>>>>>>> invalid.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If you can't explain the GROUNDS that H is using to be
>>>>>>>>>>>>>>>> ABLE to decide about Simulate(Pz,Pz) when given PP,PP,
>>>>>>>>>>>>>>>> then your logic is just broken.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Because your only purpose is to be disagreeable I force
>>>>>>>>>>>>>>> the cost of a continuing dialogue to be mutual agreement
>>>>>>>>>>>>>>> at key points in the dialogue.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I am unwilling to have any dialogue besides an honest
>>>>>>>>>>>>>>> dialogue. An honest dialogue require points of mutual
>>>>>>>>>>>>>>> agreement.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Right, so you need to explain HOW it is possible for
>>>>>>>>>>>>>> H(PP,PP) to be able to actually decide on Simulate(Pz,Pz).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Yes, so answer my questions so we can agree.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> So make the move to reach agreement. MUTUAL agreement isn't
>>>>>>>>>> one way.
>>>>>>>>>
>>>>>>>>> *You must agree with my point or I will not move on to the next
>>>>>>>>> point*
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Nope, I've given my objection, and until you answer it, I will
>>>>>>>> not move on.
>>>>>>>
>>>>>>> You have not given any objection to the precise words that said
>>>>>>> and there is no correct objection to the precise words that I
>>>>>>> said because they are proven to be true entirely on the basis of
>>>>>>> their meaning.
>>>>>>>
>>>>>>> Not agreeing with words that are true on the basis of their
>>>>>>> meaning is a sign of dishonesty.
>>>>>>>
>>>>>>
>>>>>> No, I have objected to calling something a correct decider when
>>>>>> the thing it was deciding on was not given in any way as an input.
>>>>>>
>>>>> The correct behavior of H is stipulated to be correctly determining
>>>>> whether or not it must abort the simulation of its input to prevent
>>>>> the otherwise infinite execution of this input.
>>>>>
>>>>
>>>> Then H is stipulated to not be a Halt Decider based on your
>>>> definition of this.
>>>>
>>>>> That H must abort the simulation of its input to prevent the
>>>>> infinite execution of this input is another way of saying that this
>>>>> input never stops running.
>>>>>
>>>>>
>>>>
>>>> Nope. Since you are changing the GLOBAL definition H, and not just
>>>> the instance to do your test case, you logic is invalid.
>>> It is stipulated that input the never stops running unless its
>>> simulation is aborted is input that never stops running.
>>
>> Depends on the exact meaning you give those words.
>>
>>>
>>> It is common knowledge that deciders map their finite string
>>> inputs/arguments to an accept or reject state thus conclusively
>>> proving that the behavior of P(P) is totally irrelevant to H because
>>> P(P) is not an input/argument to H.
>>>
>>>
>>
>> Nope, The finite string input to H(P,P) is the representation of P(P),
>
> If this was true then when H(P,P) correctly simulates its input this
> simulation would stop without being aborted.
>

On Fri, 02 Sep 2022 02:46:44 +0100
Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:

> Mr Flibble <flibble@reddwarf.jmc.corp> writes:
>
> > On Thu, 01 Sep 2022 19:08:17 +0100
> > Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
> >
> >> Mr Flibble <flibble@reddwarf.jmc.corp> writes:
> >>
> >> > On Thu, 01 Sep 2022 17:40:46 +0100
> >> > Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
> >> >
> >> >> Mr Flibble <flibble@reddwarf.jmc.corp> writes:
> >> >>
> >> >> > On Thu, 01 Sep 2022 17:05:54 +0100
> >> >> > Ben Bacarisse <ben.usenet@bsb.me.uk> wrote:
> >> >> >
> >> >> >> Mr Flibble <flibble@reddwarf.jmc.corp> writes:
> >> >> >>
> >> >> >> > On Thu, 1 Sep 2022 08:19:29 -0700 (PDT)
> >> >> >> > Paul N <gw7rib@aol.com> wrote:
> >> >> >> >
> >> >> >> >> You are not claiming that H refutes the well-known proof
> >> >> >> >> that a halt decider cannot exist?
> >> >> >> >
> >> >> >> > The well-known proof is the "Impossible Program"
> >> >> >> > contradiction and I have invented a halt decider that can
> >> >> >> > detect that contradiction ergo the Flibble Signaling Halt
> >> >> >> > Decider (tm) refutes that well-known proof.
> >> >> >>
> >> >> >> The well-known proof is about deciders. Not about functions
> >> >> >> that are not deciders. Not deciding is easy.
> >> >> >>
> >> >> >> Every time one teaches this material this "solution" comes
> >> >> >> up -- just detect the "pathological" case and abort, or
> >> >> >> signal, or return a third result, or don't return at all,
> >> >> >> or... (the detail about how to avoid deciding vary).
> >> >> >
> >> >> > You are a liar: I am the first to invent a decider that can
> >> >> > detect the pathological case: prove me wrong.
> >> >>
> >> >> None of the students wrote papers about non-deciders so how
> >> >> could I prove that this comes up every time? But I will put my
> >> >> reputation for honesty here up against anyone. I don't lie.
> >> >
> >> > So you have failed to prove me wrong: I am the first to invent a
> >> > decider that can detect pathological input THAT WORKS.
> >>
> >> You are not. But neither claim can be easily proved. What is
> >> certain is that you do not have a decider.
> >>
> >> >> Of course, you could submit what you consider to be am entirely
> >> >> new idea to a journal and see what they say.
> >> >
> >> > I have already published my novel decider both in this forum and
> >> > on GitHub:
> >>
> >> I meant, as you know, somewhere that cares about quality. The
> >> journal editor will tell you it's not a new idea. They won't be
> >> able to prove it either (since it's trivial), but they won't
> >> publish it.
> >> >> What is indisputable is that what you call a decider is not a
> >> >> decider. A decider accepts or rejects every problem instance.
> >> >>
> >> >
> >> > What is indisputable is that pathological input neither halts nor
> >> > doesn't halt so not giving a decision of halt or doesn't halt IS
> >> > THE CORRECT THING TO DO.
> >>
> >> That is incorrect. It's wrong in several ways. First no input
> >> halts and no input does not halt. Halting is not an intrinsic
> >> property of inputs, but a property of the computations they
> >> represent. Second, all computations (in the sense of Strachey's
> >> letter) either halt or they don't. What do you think the "others"
> >> do?
> >
> > If you want to play word games then fair enough:
>
> No, no, no. I don't want more words from you. I used words rather
> than anything formal because your claim is not based on any formal
> model but I'd much rather ditch the piles of words.
>
> Most people who have "solved the halting problem" have never read a
> proper proof of the theorem. They've read a summary of an informal
> argument, but it seems you would rather be more precise. So what
> model do you want to work with? TMs? Lambda calculus? Combinator
> forms?
>
> > what is indisputable
> > is that a computation that represents a pathological input neither
> > halts nor doesn't halt so not giving a decision of halt or doesn't
> > halt IS THE CORRECT THING TO DO.
>
> There is no known model of computation that has a third option. A TM
> halts or it does not. A lambda form reduces to a normal form or it
> does not. What model do you have in mind that does neither?
>
> > It might help your understanding if I elaborate a tad: a computation
> > that represents a pathological input is INVALID as it CANNOT EXIST
> > because it is referencing a halt decider that CANNOT EXIST UNLESS
> > THAT HALT DECIDER CAN DETECT THE PATHOLOGY.
>
> This is exactly why I don't like word waffle. Computations don't
> represent inputs, inputs represent computations, so I am stuck right
> away. Something does not exist, but what? There is no such thing as
> a non-existent computation (when the term is properly defined), and a
> non-existent input is even more daft.
>
> Let me set out one way to think about this clearly. A computation is
> the sequence of configurations (sate + tape) generated by a TM's state
> transition function. It's simplest to consider just a blank initial
> tape so there is no input to worry about. A computation "halts" if
> that sequence is finite and it "does not halt" otherwise. We can be
> loose and call the TM a computation, but it's actually the generated
> sequence that is either finite or not.
>
> We can also fix the alphabet to be, say blank, 0 and 1, and we can use
> numbers for the states so that a computation (well, the TM that
> generates the computation) just depends on the state transition
> function. These can be ordered using the usual lexicographic ordering
> for lists of tuples.
>
> Thus there is a first TM, a second TM and so. A halt decider is a TM
> that takes, on it's tape, a number, n, in binary and accepts or
> rejects depending on whether the nth TM halts given a blank initial
> tape. This is a very stripped-down model, but even here there is no
> TM that can do this.
>
> Note that there is no waffling about a computation representing inputs
> that don't exist (whatever that means). Every binary number denotes a
> computation (the nth in the sequence of possible state transition
> functions) and that state transition function either produces a finite
> computation or it does not.
>
> You may choose to call some numbers "pathological", but the numbers
> exist, the input exists (the binary digits of that number) and the TM
> so numbered by the input exists.
>
> > It is a FACT therefore that the only valid halt decider is a halt
> > decider that can detect pathological inputs and report on them
> > using a signal: which is the halt decider that I have invented.
>
> If the input that results in a signal represents a computation, then
> that signal is not a valid answer, and is what every year comes up in
> class -- detect that the input is of the "self-referential" form
> presented in the proof and abort (or signal, or whatever).
>
> If the input that results in a signal is not a computation then it
> makes no difference what you do. A halt decider only has to answer
> correctly about computations that exist -- program that can actually
> be written. A TM with any finite state transition function.
>
> I can't decode the word salad to know which is the case, but both are
> wrong.
>
> >> As usual, by avoiding a formal model (like TMs, lambda calculus,
> >> combinator forms, etc) you introduce enough waffle to be able to
> >> boast about your achievement to your heart's content. That's
> >> pretty much what it's all about -- boasting.
> >
> > I am not boasting:
>
> Of course you are. Empty boasting. There's no formal model, no
> proof, no published paper... Just grandiose claims. It's textbook
> boasting. It's as if someone said that they have a universal compiler
> that can compile any programming language with no supporting evidence.

On 9/1/2022 9:29 PM, Richard Damon wrote:
>
> On 9/1/22 8:18 PM, olcott wrote:
>> On 9/1/2022 5:52 PM, Richard Damon wrote:
>>> On 9/1/22 10:37 AM, olcott wrote:
>>>> On 9/1/2022 6:22 AM, Richard Damon wrote:
>>>>>
>>>>> On 8/31/22 11:59 PM, olcott wrote:
>>>>>> On 8/31/2022 10:19 PM, Richard Damon wrote:
>>>>>>> On 8/31/22 9:46 PM, olcott wrote:
>>>>>>>> On 8/31/2022 8:41 PM, Richard Damon wrote:
>>>>>>>>> On 8/31/22 9:29 PM, olcott wrote:
>>>>>>>>>> On 8/31/2022 8:16 PM, Richard Damon wrote:
>>>>>>>>>>> On 8/31/22 9:08 PM, olcott wrote:
>>>>>>>>>>>> On 8/31/2022 8:04 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 8/31/22 8:54 PM, olcott wrote:
>>>>>>>>>>>>>> On 8/31/2022 7:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 8/31/22 8:24 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 8/31/2022 7:14 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 8/31/22 7:59 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 8/31/2022 6:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 8/31/22 7:44 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 8/31/2022 6:04 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 8/31/22 10:37 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 8/31/2022 5:58 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 11:30 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 10:11 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 10:51 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 9:22 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 10:12 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 9:01 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 9:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 8:44 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 9:35 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 8:19 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 8:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 7:40 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/22 7:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/30/2022 5:37 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IF Px REALLY does call Simulate,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether it is the simulate you show
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (which doesn't actually simulates,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but just calls its input), then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, THAT Px is Non-Halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Great an honest reply. Now if H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> was supposed to predict the behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of a correct and complete simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input as if H was Simulate,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then H(P,P) would be correct return
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return 0.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You didn't read the rest.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H is supposed to predict whether or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not a pure simulation of its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> performed by Simulate (instead of H)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will never stop running and H returns
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 0 then H is necessarily correct no
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matter what process that H uses to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> make this determination.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But remember, P doesn't call simulate,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it calls H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) correctly predicts that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulate(x,y) never halts:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>    return 0;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But, assuming we are still talking about
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the P that calls H(P,P), Simulate(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does Halt if H(P,P) return 0, so that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer is wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void Simulate(ptr x, ptr y)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>    x(y);
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void Pz(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>    Simulate(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If Fred is supposed to determine whether
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> or not Simulate(Pz, Pz) halts:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> u32 Fred()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>    return 0;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Then Fred is necessarily correct*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, H(Pz,Pz) is correct to say 0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> void PP(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>    H(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>    Output("Input_Halts = ", H(PP, PP));
>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> void Pz(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>    Simulate(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(PP,PP) is correct to return 0 when
>>>>>>>>>>>>>>>>>>>>>>>>>>>> returning 0 means that Simulate(Pz,Pz) never
>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> How are you justifying that H(PP,PP) is
>>>>>>>>>>>>>>>>>>>>>>>>>>> answering about a TOTALLY DIFFERENT input Pz,Pz?
>>>>>>>>>>>>>>>>>>>>>>>>>> Every function that returns 0 (interpreted as
>>>>>>>>>>>>>>>>>>>>>>>>>> Boolean) is correctly answering: Does
>>>>>>>>>>>>>>>>>>>>>>>>>> Simulate(Pz,Pz) halt?
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> If that is the question it is supposed to be
>>>>>>>>>>>>>>>>>>>>>>>>> answering.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> So, your trying to claim victory by giving the
>>>>>>>>>>>>>>>>>>>>>>>>> "right' answer to the worng question.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> I am not done yet.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> *We can move* *ON* *when you agree that this is
>>>>>>>>>>>>>>>>>>>>>>>> true*
>>>>>>>>>>>>>>>>>>>>>>>> H(PP,PP) is correct to return 0 when returning 0
>>>>>>>>>>>>>>>>>>>>>>>> means that
>>>>>>>>>>>>>>>>>>>>>>>> Simulate(Pz,Pz) never halts.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> So, you are stipulating that H isn't a halt decider.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> I am stipulating that H(PP,PP) is a halt decider
>>>>>>>>>>>>>>>>>>>>>> for Simulate(Pz,Pz)
>>>>>>>>>>>>>>>>>>>>>> Thus H(PP,PP)==0 is correct.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> What is Hz? did you mean Pz?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Yes it was a typo.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> And how is it that? Since H hasn't been given
>>>>>>>>>>>>>>>>>>>>> anything about Pz, so how can it be being asked
>>>>>>>>>>>>>>>>>>>>> about it.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> If when I say "there is a black cat sitting on my
>>>>>>>>>>>>>>>>>>>> head" is code for 2 + 3 = 5, then "there is a black
>>>>>>>>>>>>>>>>>>>> cat sitting on my head" is true.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> In this same way when I say that when H(PP,PP)
>>>>>>>>>>>>>>>>>>>> returns 0 this means that Simulate(Pz,Pz) never
>>>>>>>>>>>>>>>>>>>> halts then H(PP,PP)==0 is correct.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> And things based on nonsense are just nonsense.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You misdefine too many things to be allowed to play
>>>>>>>>>>>>>>>>>>> that game.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Being "Correct" means does what it is supposed to do.
>>>>>>>>>>>>>>>>>>> Until you actually DEFINE how H is "correct" to do
>>>>>>>>>>>>>>>>>>> this, you are just stating non-sense.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Remember, you aren't allowed to stipulate something
>>>>>>>>>>>>>>>>>>> is correct.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> This is a mandatory prerequisite to the rest of my proof.
>>>>>>>>>>>>>>>>>> I understand if you just want to disagree and don't
>>>>>>>>>>>>>>>>>> want to understand.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If it is a mandatory prerequisite, then your proof is
>>>>>>>>>>>>>>>>> invalid.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If you can't explain the GROUNDS that H is using to be
>>>>>>>>>>>>>>>>> ABLE to decide about Simulate(Pz,Pz) when given PP,PP,
>>>>>>>>>>>>>>>>> then your logic is just broken.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Because your only purpose is to be disagreeable I force
>>>>>>>>>>>>>>>> the cost of a continuing dialogue to be mutual agreement
>>>>>>>>>>>>>>>> at key points in the dialogue.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I am unwilling to have any dialogue besides an honest
>>>>>>>>>>>>>>>> dialogue. An honest dialogue require points of mutual
>>>>>>>>>>>>>>>> agreement.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Right, so you need to explain HOW it is possible for
>>>>>>>>>>>>>>> H(PP,PP) to be able to actually decide on Simulate(Pz,Pz).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Yes, so answer my questions so we can agree.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>>>>> *We must have have mutual agreement to proceed*
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> So make the move to reach agreement. MUTUAL agreement isn't
>>>>>>>>>>> one way.
>>>>>>>>>>
>>>>>>>>>> *You must agree with my point or I will not move on to the
>>>>>>>>>> next point*
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Nope, I've given my objection, and until you answer it, I will
>>>>>>>>> not move on.
>>>>>>>>
>>>>>>>> You have not given any objection to the precise words that said
>>>>>>>> and there is no correct objection to the precise words that I
>>>>>>>> said because they are proven to be true entirely on the basis of
>>>>>>>> their meaning.
>>>>>>>>
>>>>>>>> Not agreeing with words that are true on the basis of their
>>>>>>>> meaning is a sign of dishonesty.
>>>>>>>>
>>>>>>>
>>>>>>> No, I have objected to calling something a correct decider when
>>>>>>> the thing it was deciding on was not given in any way as an input.
>>>>>>>
>>>>>> The correct behavior of H is stipulated to be correctly
>>>>>> determining whether or not it must abort the simulation of its
>>>>>> input to prevent the otherwise infinite execution of this input.
>>>>>>
>>>>>
>>>>> Then H is stipulated to not be a Halt Decider based on your
>>>>> definition of this.
>>>>>
>>>>>> That H must abort the simulation of its input to prevent the
>>>>>> infinite execution of this input is another way of saying that
>>>>>> this input never stops running.
>>>>>>
>>>>>>
>>>>>
>>>>> Nope. Since you are changing the GLOBAL definition H, and not just
>>>>> the instance to do your test case, you logic is invalid.
>>>> It is stipulated that input the never stops running unless its
>>>> simulation is aborted is input that never stops running.
>>>
>>> Depends on the exact meaning you give those words.
>>>
>>>>
>>>> It is common knowledge that deciders map their finite string
>>>> inputs/arguments to an accept or reject state thus conclusively
>>>> proving that the behavior of P(P) is totally irrelevant to H because
>>>> P(P) is not an input/argument to H.
>>>>
>>>>
>>>
>>> Nope, The finite string input to H(P,P) is the representation of P(P),
>>
>> If this was true then when H(P,P) correctly simulates its input this
>> simulation would stop without being aborted.
>>
>
> No, because your definition of H aborts its simulation
Means that empirical testing proves that the simulation does not
otherwise ever stop running.

On 9/1/22 11:02 PM, olcott wrote:
> On 9/1/2022 9:29 PM, Richard Damon wrote:
>>
>> On 9/1/22 8:18 PM, olcott wrote:
>>> On 9/1/2022 5:52 PM, Richard Damon wrote:
>>>> On 9/1/22 10:37 AM, olcott wrote:
>>>
>>>> Nope, The finite string input to H(P,P) is the representation of P(P),
>>>
>>> If this was true then when H(P,P) correctly simulates its input this
>>> simulation would stop without being aborted.
>>>
>>
>> No, because your definition of H aborts its simulation
> Means that empirical testing proves that the simulation does not
> otherwise ever stop running.
>

Nope, because the "empirical test" you use isn't valid, because it
doesn't meet the ACTUAL definition of the problem, only your INCORRECT
paraphrase of it.

The ACTUAL emperical test, which shows that it does halt, is to just run
the input, or give it to a simulator that does an actual complete
simulation. These shows it halts.

Maybe you can emperically prove that H is a correct POOP decider, but
that isn't your claim.

FAIL.