This ChatGPT can be replicated it contains the full dialogue

[olcott]

olcott
void D(void (*x)())
{
int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return;
}


int main()
{
Output("Input_Halts = ", H(D, D));
}

This first sentence is an established fact: When H(D,D) correctly
simulates its input the execution trace of this simulated input proves
that it would never stop running because D continues to call H in
recursive simulation. Then H aborts its simulation of D and returns 0 to
main, indicating that D would never stop running unless aborted. Is H
correct?

ChatGPT
Yes, if H correctly simulates its input and the execution trace of the
simulated input proves that D would never stop running unless aborted,
then H would return 0 to main, indicating that D would never stop running.

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

[olcott]

On 1/30/2023 11:54 AM, olcott wrote:
> olcott
> void D(void (*x)())
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return;
> }
>
>
> int main()
> {
>   Output("Input_Halts = ", H(D, D));
> }
>
> This first sentence is an established fact: When H(D,D) correctly
> simulates its input the execution trace of this simulated input proves
> that it would never stop running because D continues to call H in
> recursive simulation. Then H aborts its simulation of D and returns 0 to
> main, indicating that D would never stop running unless aborted. Is H
> correct?
>
> ChatGPT
> Yes, if H correctly simulates its input and the execution trace of the
> simulated input proves that D would never stop running unless aborted,
> then H would return 0 to main, indicating that D would never stop running.
>

Simplified from above, this was replicated in a new dialogue
Removed "This first sentence is an established fact:"

olcott
void D(void (*x)())
{
int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return;
}


int main()
{
Output("Input_Halts = ", H(D, D));
}

When H(D,D) correctly simulates its input the execution trace of this
simulated input proves that it would never stop running because D
continues to call H in recursive simulation. Then H aborts its
simulation of D and returns 0 to main, indicating that D would never
stop running unless aborted. Is H correct?

ChatGPT

Yes, H is correct if it correctly simulates its input and the execution
trace of the simulated input shows that D never stops running unless
aborted.

[Richard Damon]

On 1/30/23 12:54 PM, olcott wrote:
> olcott
> void D(void (*x)())
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return;
> }
>
>
> int main()
> {
>   Output("Input_Halts = ", H(D, D));
> }
>
> This first sentence is an established fact: When H(D,D) correctly
> simulates its input the execution trace of this simulated input proves
> that it would never stop running because D continues to call H in
> recursive simulation. Then H aborts its simulation of D and returns 0 to
> main, indicating that D would never stop running unless aborted. Is H
> correct?

So, you are LYING to ChatGPT, because H doesn't actully simulate its
input correctly per the definitons needed.

>
> ChatGPT
> Yes, if H correctly simulates its input and the execution trace of the
> simulated input proves that D would never stop running unless aborted,
> then H would return 0 to main, indicating that D would never stop running.
>

So, ChatGPT agrees that only if H correctly simulates the input to the
point of being able to actually PROVE it would not stop unless aborted.


Note, H(D,D) seeing D(D) calling H(D,D) doesn't meet that proof, since
that called H(D,D) WILL return 0 at some point in the future since this
H(D,D) does.

FAIL.

[Mr Flibble]

On Mon, 30 Jan 2023 18:43:00 -0500, Richard Damon wrote:

> On 1/30/23 12:54 PM, olcott wrote:
>> olcott void D(void (*x)())
>> {
>>   int Halt_Status = H(x, x);
>>   if (Halt_Status)
>>     HERE: goto HERE;
>>   return;
>> }
>>
>>
>> int main()
>> {
>>   Output("Input_Halts = ", H(D, D));
>> }
>>
>> This first sentence is an established fact: When H(D,D) correctly
>> simulates its input the execution trace of this simulated input proves
>> that it would never stop running because D continues to call H in
>> recursive simulation. Then H aborts its simulation of D and returns 0
>> to main, indicating that D would never stop running unless aborted. Is
>> H correct?
>
> So, you are LYING to ChatGPT, because H doesn't actully simulate its
> input correctly per the definitons needed.

Giving ChatGPT an ASSUMPTION is NOT lying to it; I told ChatGPT to assume
that a function was a halt decider through the use of a comment and
ChatGPT correctly asserted that you cannot use a halt decider on
pathological (self referencing) input (i.e. the category error in the
definition of the problem a novel new addition to research that I made).

/Flibble

[Richard Damon]

Saying tha H(D,D) correctly simulates its input far enough to actually
PROVE the input will not halt is just a LIE.

ChatGPT obviously can't recognise a Curry Paradox.

The statment that H is correct in determining its answer is dependent on
the assumtion that H will be correct, and can be correct, and thus the
statement is NOT established by this arguement.

You need to establish H being corret without making those assumptions.

That form of arguement allows for Curry's Paradox, which are statements
of the form

If this statement is True, then xxxx

Which can be used to establish ANY statement xxxx.

[Python]

https://www.linkedin.com/pulse/high-time-take-chatgpt-offline-aleksandr-tiulkanov

[Mostowski Collapse]

ChatGPT is not a good advisor in math:

Q: How is 15 * 15 * 15 * 15 * 15 * 15 * 15 * 15 * 15 * 15 = 32,576,665,039,062 ?

A: My apologies, that was a mistake in my previous response.
15 * 15 * 15 * 15 * 15 * 15 * 15 * 15 * 15 * 15 is actually equal to:

15,625,065,353,560,625

And this number is indeed odd, not even as I previously stated.
Thank you for bringing this to my attention.

Credits: https://9gag.com/gag/a4o1jqv#comment

[olcott]

*Any formal system that does not conform to this is unsound*
Analytical truth is the connection from an expression X of formal or
natural language L using truth preserving operations to expressions of L
that have been stipulated to be true. Copyright 2023 PL Olcott

[Python]

ChatGPT is not designed for truth, the same way you are not interested
in truth as you are only spitting lies.

[olcott]

No one could even point to single (non trivial) error in anything that I
said.

[Python]

Most people here did. Don't be silly (or lying, or both).

[Richard Damon]

No, MANY errors have been pointed out.

You are just too stupid to understand, or just a pathological lair.


The biggest lie is that even though D(D) halts, which you admit, and
this is what H(D,D) is asking about, you insists that it saying it is
non-halting is correct.

THAT IS JUST A FLAT OUT LIE.

A Halting Computation is Halting, not non-halting, and any "alternate"
version of the question that supports a different answer, can't be an
actual correct alternate.

Your insistance on this just proves you are a Pathological Liar.

[Richard Damon]

So why do you praise it for agreeing with you, when it doesn't even
attempt to follow that rule?

[olcott]

No one could *correctly* point to single (non trivial) error in anything
that I said. Most people here incorrectly paraphrase what I said and
then provide a rebuttal to their incorrect paraphrase.

Ben's rebuttal to things that I said previously may seem plausible until
evaluated within the context of my simpler and clearer restatements of
my position.

[Chris M. Thomasson]

On 1/30/2023 9:54 AM, olcott wrote:
> olcott
> void D(void (*x)())
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return;
> }
>
>
> int main()
> {
>   Output("Input_Halts = ", H(D, D));
> }
>
> This first sentence is an established fact: When H(D,D) correctly
> simulates its input the execution trace of this simulated input proves
> that it would never stop running because D continues to call H in
> recursive simulation. Then H aborts its simulation of D and returns 0 to
> main, indicating that D would never stop running unless aborted. Is H
> correct?
>
> ChatGPT
> Yes, if H correctly simulates its input and the execution trace of the
> simulated input proves that D would never stop running unless aborted,
> then H would return 0 to main, indicating that D would never stop running.
>

When will the process X halt? X is a software written by another person
that gives a hint. X might halt, or it might not... ;^)

[Richard Damon]

No, there have been MANY rebuttals for your statements, you just
refuse to look at them.

Would you be willing to make that statement in court, under penalty of
perjury, with the archives of this group avail for the jury?

>
> Ben's rebuttal to things that I said previously may seem plausible until
> evaluated within the context of my simpler and clearer restatements of
> my position.
>

So you are saying the is itsn't true what he says?

WHich fact to you disagree with?

That H(D,D) returns 0?

That D(D) will Halt since H(D,D) returns 0?

That the DEFINITON of the Halting problem is to design a machine that
return the correct answer about the halting behavior of the machine with
input that is described by the input to H?

That D(D) Halting means that answer should be Halting?

That you claim that H(D,D) even though it gave a different answer than
the one given by the defition of the problem is still right?

[olcott]

Process X is not mentioned because no details have been provided for
process X.

[Mr Flibble]

Curry's paradox doesn't apply in this case as the relationship between the
assumption and the conclusion is not disjoint.

/Flibble

[Chris M. Thomasson]

Process X was written by another person. Will your program have any
trouble with it? Humm...

[olcott]

Since I have shown that a simulating halt decider does correctly
determine the halt status of the conventional counter-example basis used
by all of the conventional halting problem proofs these proofs lose
their entire basis and fail.

Whether or not halting is decidable may now have been transformed into
an open problem.

[Richard Damon]

No, you have shown that you can use an unsound arguement to try to show
that a wrong answer is correct.

After all, you HAVE admitted that P(P) does Halt, so when we ask H via
H(P,P) if P(P) Halts, the correct answer IS Halt (1), but you 'claim'
via FAULTY logic that non-halting is also an answer.

Your logic uses logic that supports Curry's paradox, so, by your logic,
since the statement:

If this statement is True, then Peter Olcott is a Pathological Liar

is a provable statement, and thus true, you are admitting that you are
just a Pathological liar.

Your logic starts with the implicit assumption that H CAN give the
correct answer (which has been disproven) and from that you prove that
it gives the correct answer. It Truth, from that assumption you can
prove anything at all, due to the principle of explosion.

[Richard Damon]

SO, you don't understand the nature of Curry's Paradox.

It isn't that the listed conclusion is disjoint causes the problem, it
just helps demonstrate it.

The problem is if you need to "assume" the Truth of the statement, to
prove the truth of the statement, you haven't actually demonstrated that
it is, or even CAN be true.


H's corretness is based on the assumption that H CAN be correct, which
it has been proven it can't be.

By allowing the assumption you bring in the logic form that enables
Curry's Paradox.

[Mr Flibble]

Nope, Curry's Paradox doesn't apply as this is basically a hypothesis: the
assumption doesn't say anything about the truth of the conclusion, it
merely sets the scene for the conclusion. You really need to brush up on
your logic skills and English compreshension, Richard Damon, as you are
coming across as quite amateurish.

/Flibble

[Richard Damon]

Your wrong, You can't prove a hypothosis by assuming it to be true and
showing something.

By assuming that "H simulates the input correctly and correctly
determines that in input will not halt" is assuming that this CAN be
done, which it can't.

The fact that you can't recognize one of the fundamental fallicies of
classical logic shows that YOU are the one being amateurish.

That the statement is wrong can be done by a simple demonstration.

First Show that H(D,D) returns 0.

Then run D(D) and see that it halts.

SInce the DEFINITION of a Halt Decider is that its answer is supposed to
match the actual behavior of running the input, H is obviously wrong.

To claim that it correctly predicted what a correct simulation would do
is obviously wrong, as shown buy just running UTM(D,D) which will also halt.

To claim that it correctlr predecited whaat a correct simulation by H
would do is wrong, because we just showed what a "Correct Simulation"
does, and a "Correct Simulation by X" must match what a general "Correct
SImulation" does, or it isn't actualy a "Correct Simulation"

Thus the claim that H "Got the right asnwer" is invalidated. It is
proven that H never did a correct simulation to correctly show
something, since that isn't what is true.

Any claim that it is, is just a claim that a false statement must be
true "Because". All that it proves is that the logic used to say
"Because" must be wrong.

Please specify exactly which FACT I quoted you consider incorrect.

[Mr Flibble]

So amateurish! The premises for a hypothesis do not have to be proven to
be true; that is only a requirement when converting a hypothesis into a
theory. I guess you skipped logic and science class, dummy.

/Flibble

[Richard Damon]

But until the premisis of the hypothesis ARE proven to be true, the
conclusion is not established.

So yes, if you can PROVE that H does a tually CORRECTLY predicts that
the correct simulation of the machine at its input would run forever,
then you can make your conclusion.

Note, Not reaching the final state is not the same as would simulate
forever if you allow the simulation to abort. The fact that partial
simulation doesn't reach a final state just puts a lower bound on the
execution time of the machine, it doesn't make it non-halting.

Oclott's "Proof" based on H(D,D) simulating D(D) to a call to H(D,D) is
NOT an actual proof, as that doesn't not actually prove the claim.

If fact, the knowledge that H(D,D) WILL abort is simulation and return 0
provds that D(D) will Halt.