Re: HHH(DDD)==0 is correct

On 7/3/25 7:15 PM, olcott wrote:

On 7/3/2025 5:59 PM, Richard Damon wrote:

On 7/3/25 11:17 AM, olcott wrote:

On 7/3/2025 9:50 AM, Richard Damon wrote:

On 7/3/25 10:39 AM, olcott wrote:

On 7/3/2025 9:16 AM, Richard Damon wrote:

On 7/2/25 10:50 PM, olcott wrote:

On 7/1/2025 11:37 AM, Mr Flibble wrote:

On Mon, 30 Jun 2025 21:12:48 -0400, Richard Damon wrote:
>

On 6/30/25 2:30 PM, Mr Flibble wrote:
>
PO just works off the lie that a correct simulation of the input is
different than the direct execution, even though he can't show the
instruction actually correctly simulated where they differ, and thus
proves he is lying.
>
The closest he comes is claiming that the simulation of the "Call HHH"
must be different when simulated then when executed, as for "some
reason" it must be just because otherwise HHH can't do the simulation.
>
Sorry, not being able to do something doesn't mean you get to redefine
it,
>
You ar4e just showing you are as stupid as he is.

>
No. A simulator does not have to run a simulation to completion if it can
determine that the input, A PROGRAM, never halts.
>
/Flibble

>
The most direct way to analyze this is that
HHH(DDD)==0 and HHH1(DDD)==1 are both correct
because DDD calls HHH(DDD) in recursive simulation and
DDD does not call HHH1(DDD) in recursive simulation.

>
Nope. It seems you don't understand what the question actually IS because you have just lied to yourself so much that you lost the understanding of the queiston.
>

>
*I can't imagine how Mike does not get this*

>
I can't understand
>

>
*Context of above dialogue*
*Context of above dialogue*
*Context of above dialogue*

>
Context of your context:
>
A Halt Decider is supposed to decide if the program given to it (via some correct representation) will halt when run.
>
Thus, "the input" needs to represent a program
>

>
typedef void (*ptr)();
int HHH(ptr P);
>
void DDD()
{
   HHH(DDD);
   return;
}
>
int main()
{
   HHH(DDD);
}

>
Which, by itself, isn't a valid input, or program. as HHH is undefined.
>
Each different definition of HHH, gives a different problem.
>
Your "logic" seems to be based on trying to re-define what a program is, which just makes it a lie.
>
"Programs" must be complete and self-contained in the field of computability theory, something you don't seem to understand.
>

>
Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0. (HHH1 has identical code)
>
>

>
But it CAN'T simulate the above input. as it isn't valid.
>
You need to add the code of HHH to the input to let HHH simulate "the input" to get anything.
>

>
No I do not. The above paragraph has every detail that is needed.

>
Then how do you correctly simulate something you do not have.
>
Note, your "description" of HHH is just incorrect, as it is also incomplete.
>
Simulating a LIE just gives you a lie.
>

>

And at that point, you have different inputs for different HHHs, and possibly different behaviors, which you logic forgets to take into account, which just breaks it.
>

>
Wrong.
It is because the what I specified does take this
into account that HHH(DDD)==0 and HHH1(DDD)==1 are correct.

>
Nope, becausee it violates the DEFINITION of what it means to simulate something.
>

>
*You don't even know what you mean by this*
What I mean is the execution trace that is derived
within the semantics of the C programming language.

>
Right, which means that the input needs to include the code of HHH.
>
And when you do so, there is only one possible HHH for that input, as it has been specified in the input, and any other HHH trying to be defined breaks the one-definition rule.
>
>

>
HHH1 simulates DDD that calls HHH(DDD) that
simulates DDD and then simulates itself simulating DDD.
Then HHH(DDD) aborts its simulation and returns to the
DDD simulated by HHH1. Then this DDD returns to HHH1.

>
Right, it aborts it, but the CORRECT simulation of that input would be to see that
>
DDD calls HHH that simulates DDD that calls HHH and then the first HHH aborts its simulation and returns to DDD which then halts.
>
Thus, the input is HALTING, as shown by the CORRECT simulation.
>

>
*Claude (smarter than ChatGPT) figured this out on its own*
https://claude.ai/share/da9b8e3f-eb16-42ca-a9e8-913f4b88202c
>

>
Since your input includes your LIE:
>
Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern.
>
Since the pattern you claim to be a "non-terminating" pattern can not actually be one, as it exists in the correct simulation that halt, say your arguement is just UNSOUND.
>
As you are just proving that you yourself are (that is unsound), as you believe your own lies.

 *I am NOT the liar here*
 

Sure you are. WHy isn't it a lie, since it is wrong.
Note, by the definition of the C language, your input, as stated, it just invalid, and will give an error from HHH being underfined.
At "Compile" time with a modern version of the standard, at link time (which is required to define the meaning of the code) for an older standard.
Of course, if you include your Halt7.c as "part of the input" then you can only have ONE HHH, and it is just proven wrong, and its simulation of HHH just shown to be incorrect.
Sorry, all you are doing is proving that you ARE just a liar, and just claiming you are not doesn't change the facts.
You need to actually try to rebute one of the errors shown.
Really, you need to rebute them all, but you need to start with one.
And you need to reference actual FACTUAL sources for your claims, which you have shown yourself unable to actually do.