Re: ChatGPT agrees that HHH refutes the standard halting problem proof method

On 7/1/25 8:07 AM, olcott wrote:

On 7/1/2025 6:28 AM, Richard Damon wrote:

On 6/30/25 9:26 PM, olcott wrote:

On 6/30/2025 8:10 PM, Richard Damon wrote:

On 6/30/25 1:00 PM, olcott wrote:

>
One line of C source-code is a C statement.
HHH simulates six statements of DDD.

>
No it doesn't, as that line of C refers to HHH, and to process that line, you need to process ALL the lines in HHH.
>

>
Yes this is true.
What the F did you think that I meant by:
>
HHH simulates DDD that calls HHH
that simulates DDD that calls HHH
that simulates DDD that calls HHH
that simulates DDD that calls HHH
that simulates DDD that calls HHH
that simulates DDD that calls HHH...

>
Except that isn't what you said HHH does!
>
YOu said HHH simulated DDD until it recognizes a non-halting pattern.
>
You have omitted this in your "loop"
>

 Recursive emulation is not a loop.

But the description is.
Attempted side track again, because you can't answer the refutation.

 

It should be:
HHH simulated DDD that calls HHH, until it recognizes a non-halting pattern,
Which results in it simulating HHH simulating DDD until it recognizes a non-halting pattern...
Which results in it simulating HHH simulating DDD until it recognizes a non-halting pattern...
Which results in it simulating HHH simulating DDD until it recognizes a non-halting pattern...
Which results in it simulating HHH simulating DDD until it recognizes a non-halting pattern...
>

 It is more precisely accurate the way that you
did it yet too confusing to get the gist of the
idea of recursive emulation.

No, your method just adds enough LIE to seem to support you LIE.
This is just your normal modus operandi, you need to "simplify" a statement to be "more understandable", but in doing so you twist its meaning so it is no longer correct.
It seems "Truth" and "Correct" are not important concepts to you, but then, you have proven yourself to be a pathological liar, so that is expected.

 

The problem is when you include that we KNOW that, since the outer HHH *WILL* at some point abort (since you assume that will happen) that this simulated HHH will also do that, and thus make the DDD that called it halting.
>

 If you are going to call impossibly reaching its final halt state
halting you might as well call it also makes you breakfast in bed.

But it isn't impossible for the machine to reach its final state (if it is built on an actual decider).
It is just impossible to make a version of it that this state can be reached by its decider.
And, as I said, if HHH is a decider, then DDD does halt.
You are just stuck in your lying strawman "definition" of Halting, since you forget what it is that needs to reach the final state.

 

Your problem is you didn't CORRECTLY simulate the HHH that DDD calls, as you ERRONEOUSLY assumed that it will not halt in order to claim that you have a non-halting pattern.
>

 When N x86 instructions of DDD are simulated
according to the semantics of the x86 language
then N N x86 instructions of DDD are simulated
correctly. This includes HHH simulating itself
simulating DDD at least once.

WHich just isn't a COMPLETE CORRECT simulation, which is what the meaning of "Correct Simulation" refers to.
I guess you think getting the first question (like putting in your name) on the IQ test and then stopping means you correctly answered the test.

 I don't understand why this is so difficult for
you unless you grossly exaggerated your competence
at programming.

It isn't, because I know the right definitions.
What is surprising is how slow you are proving that you are, by just flat out refusing to accept that correct definitions and hold onto you lies.

 

THe problem is whatever criteria is used to abort, is part of the code that is being analyized, and thus you need to take that into account when you try to prove that the pattern is non-halting.
>

 Repeat this to yourself 500 times so that you will
remember it by the time you make your next reply.
 *DDD correctly simulated by HHH cannot possibly reach*
*its own simulated "return" statement final halt state*
 *DDD correctly simulated by HHH cannot possibly reach*
*its own simulated "return" statement final halt state*
 *DDD correctly simulated by HHH cannot possibly reach*
*its own simulated "return" statement final halt state*

And the HHH that answers does not correct simulate ITS DDD, and has a different DDD then the one that was correctly simulated by a different HHH.
It seems you don't understand that fact.
Or, you statement is just a total lie, because you think DDD doesn't include the code for HHH as part of it, at which point NO HHH correctly simulates it, since a correct simulation of a program fragment that tries to use the routine that isn't part of it is just impossible, since it turns out not to be a program, and doesn't have behaivor.
This is one of your fundamental basis of lies in your logic.
Your "logic" has an essental equivocation on what the input is, which yoy can't clearify, as what ever answer you give you end up admitting that you have been lying.
Sorry, all you are doing is showing that you are so stupid you can't undetstand that simple of a problem with your "logic"

 

Your "logic" doesn't understand how programs work and are defined, because your "logic" comes out of your own ignorance of the field.
>

>
>

You are just showing you don't understand the basics of how computers and programs work.
>

>

Note, "C" doesn't define "instructions", but operations as defined by the abstract machine.
>
The operations defined in DDD:
>
Fetch the value of DDD
Pass that as a parameter to HHH
Call the funciton HHH,
Perform the operations of function HHH
Return
>

>
At the machine language level HHH correctly
simulated four x86 instructions of DDD six times.

>
Nope, doesn't simulate the CALL instruction.
>

>
Yes it does.

>
Then why doesn't it show the x86 instuctions executed?
>
Of the sequence points inside of the HHH that it called?
>

>
What the F did you think that I meant by:
HHH simulates DDD that calls HHH
that simulates DDD that calls HHH
that simulates DDD that calls HHH
that simulates DDD that calls HHH
that simulates DDD that calls HHH
that simulates DDD that calls HHH...
>
>

>
As I said, that isn't a simulation of HHH, as that isn't what HHH doess, because it LIES about the fact that HHH, as you have defined it, *WILL* abort and return 0, and thus every DDD will halt.
>
All you are doing is proving that you don't understand what you are talkinga about, and just refuse to look at the facts, because you are just a pathological liar that has been brainwashed by yourself into unconditionaly believing your own lies.