Re: Flat out dishonest or totally ignorant?

On 7/1/24 10:09 PM, olcott wrote:

On 7/1/2024 8:51 PM, Richard Damon wrote:

On 7/1/24 9:25 PM, olcott wrote:

typedef void (*ptr)();
int HHH(ptr P);
>
void Infinite_Loop()
{
   HERE: goto HERE;
}
>
void Infinite_Recursion()
{
   Infinite_Recursion();
}
>
void DDD()
{
   HHH(DDD);
}
>
int main()
{
   HHH(Infinite_Loop);
   HHH(Infinite_Recursion);
   HHH(DDD);
}
>
Every C programmer that knows what an x86 emulator is knows
that when HHH emulates the machine language of Infinite_Loop,
Infinite_Recursion, and DDD that it must abort these emulations
so that itself can terminate normally.

>
Right.
>

 Then why do you contradict yourself below? Did you forget to lie?

Because I didn't contradict my self or lie, as the programs are different.
A well written decider should be able to tell that UTM(Infinite_Loop) and UTM(Infinite_recursion) will never halt.
But, given that HHH(DDD) *WILL* abort its emulation and return, then UTM(DDD) (which still calls HHH) will be able to emulate DDD calling HHH(DDD) which will eventually abort its emulation of the inner DDD and return to the calling DDD and then the program will halt.
This DDD is NOT non-halting but halting, and never had "infinite recursion"

 

>
When this is construed as non-halting criteria then simulating
termination analyzer HHH is correct to reject these inputs as
non-halting by returning 0 to its caller.

>
But only when you can actually PROVE that the full emulation of the program would be non-halting.
>

 Too late you already agreed.
You must have forgot to lie.

Nope, but apparently not to late for you to lie AGAIN. You keep on making the stupid error, probably because you don't know better, that two different programs must act the same.

 

>
Simulating termination analyzers must report on the behavior
that their finite string input specifies thus HHH must report
that DDD correctly emulated by HHH remains stuck in recursive
simulation.

>
But if DDD WAS stuck in infinte recursion, so must be HHH, so it isn't a decider.
>

 Too late, you already agreed that HHH(DDD) is correct.
 

WHere?
You are just a LIAR. And heading for the hot time in Gehenna soon.

HHH can't have different behavior when emulated by HHH then when it is actually run.
>
The problem is that "Emulated by the Decider" is NOT a valid criteria for the behavior of the input, since it isn't a function of just the input.
>

Sure it is. If we don't do it that way then we stupidly
ignore that HHH(DDD) must abort its emulation.

Nope, that means something is a function of something it isn't defined to be a function of.
In other words, your definition is just a LIE.

 

The "Behavior of the input" will be the behavior of the program the input represents when it is run.

 If we assume that then we stupidly ignore that
HHH(DDD) must abort its emulation.

But that doesn't give it the right to give the wrong answer.
I guess you are just admitting that you logic is based on the premise that it is ok to lie if you want to.
That makes Election Deniers and Climate Change Deniers correct in their claims.

 Basically it is too late you forget to lie and told the truth
on the first point thus contradicting yourself on every other point.
 

Nope, I agree that a decider can get the first two, which is all you mentioned.
You just fell into your own trap and made yourself into a clear liar,
Of course, you seem to do that every time you speak.