Re: HHH(DDD)==0 is correct

On 7/9/25 8:45 AM, olcott wrote:

On 7/9/2025 3:32 AM, Mikko wrote:

On 2025-07-08 14:16:13 +0000, olcott said:
>

On 7/8/2025 2:35 AM, Mikko wrote:

On 2025-07-07 14:02:49 +0000, olcott said:
>

On 7/7/2025 3:25 AM, Mikko wrote:

On 2025-07-06 15:00:25 +0000, olcott said:
>

On 7/6/2025 4:19 AM, Mikko wrote:

On 2025-07-05 15:59:50 +0000, olcott said:
>

On 7/5/2025 2:30 AM, Fred. Zwarts wrote:

Op 04.jul.2025 om 14:57 schreef olcott:

On 7/4/2025 2:42 AM, Mikko wrote:

On 2025-07-03 15:17:53 +0000, olcott said:
>

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.

>
C lanbuage definition does not specifiy the senatics of the non- standard
lanugage extension that your HHH and HHH1 use.

>
>
*This is the ONLY specification of HHH that chatbots see*
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.

>
There is no non-termination behaviour to detect, because the input specifies only a *finite* recursion.

>
When DDD is infinitely simulated by HHH it never reaches

>
When DDD is infinitely simulated by HHH that HHH never answers correctly
(or otherwise) and therefore is not a halting decider.

>
So by a kind of mathematical induction HHH correctly
predicts that DDD simulated by HHH (according to the
semantics of the C programming language) cannot possibly
reach its own simulated "return" statement final halt
state then HHH is correct to reject DDD as non-halting.

>
"By a kind of mathematical induction" is not a valid basis for inference.

>
void DDD()
{
   HHH(DDD);
   return;
}
>
DDD simulated by HHH according to the semantics
of the C programming language specifies
>
HHH simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)...

>
Simply reading the code of your HHH shows that that is not what happens.
Your HHH does not simulate that many levels of recorsion.

>
I was showing the pattern of behavior that HHH recognizes.

>
As the input to HHH does not match to that pattern

  *Here is HHH matching that pattern*
executed HHH simulates DDD that calls emulated HHH(DDD)
that simulates DDD that calls emulated emulated HHH(DDD)

But that pattern isn't what actually happens, because the first simulated HHH will abort before it gets that far, because HHH aborts before it lets its simulation get that far.

 *Here is the 197 page full execution trace of that*
https://liarparadox.org/HHH(DDD)_Full_Trace.pdf

Right, wh9ch shows that HHH aborts on the conditon of seeing that its input calls HHH and it simulates that to a repeat of that call.
It also proves that the CORRECT simulation of this input, will reach a final state, and thus that it this isn't a non-halting pattern.

 Line 996 is where it matches the above pattern.
https://github.com/plolcott/x86utm/blob/master/Halt7.c

No, that isn't the pattern it is matching, I guess you don't understand your own program.
The pattern it matchs is seeing HHH simulate an input to a call to HHH with the same input.
Since you show that EVERY HHH will abort such a simulation, your pattern above doesn't actually exist, it is just you lying to yourself.

 

you should say
"hallucinates" instead of "recognizes". Though that does not alter
the end result that HHH gives the wrong answer.
>