Re: Hypothetical possibilities

On 7/20/24 2:52 PM, olcott wrote:

On 7/20/2024 11:01 AM, Richard Damon wrote:

On 7/20/24 11:28 AM, olcott wrote:

void DDD()
{
   HHH(DDD);
}
>
int main()
{
   DDD();
}
>
(a) Termination Analyzers / Partial Halt Deciders must halt
this is a design requirement.

>
I don't know where you got the false idea that "Termination Analyzers" were "Partial Halt Deciders", then most certainly are not.
>
Read https://en.wikipedia.org/wiki/Termination_analysis for a description, they deal with the related problem of determining if the input program will halt for *ALL* inputs, not just a given one.
>
>
Yes, in computer science, where the building of partial Termination Analyzers is an ongoing project, they often just drop the assumed partial as everyone know the general problem is not universally solvable.
>
Also, the answer must be correct,
>
and the input must be a PROGRAM, which mean it includes ALL its code that it uses, so for DDD, include the code for HHH.
>

>
(b) Every simulating termination analyzer HHH either
aborts the simulation of its input or not.
>
(c) Within the hypothetical case where HHH does not abort
the simulation of its input {HHH, emulated DDD and executed DDD}
never stop running.

>
But that is a DIFFERENT DDD then the one given to the HHH that aborted it emulation, and thus your logic is based on LYING.
>

 Sure of course everyone knows that when you examine
every element of an infinite set that there are a
whole bunch of elements of this infinite set that you
never examined after you have examined every single
one of them.

Who said there were some that weren't looked at?
That is just another of your near infinite set of lies.
We can look at EVERY ELEMENT in that infinite set, and every case falls into one of two cases:
Case 1: The HHH(DDD) *WILL* abort its emulation of the DDD it is given, that thus, does NOT "Correctly Emulate" its input per the FULL semantics of the x86 (since just stopping but not halting in the middle of the program doesn't match those semantics) and the DDD that was paired to such an HHH *WILL* reach its final state when run or correctly emulated by an ACTUAL correct emulator given the exact same input including the fact that it calls the HHH that aborts.
Case 2: The HHH(DDD) NEVER aborts its emulation of the DDD it is given, at which point that HHH will never return an answer. You acknoledge that this HHH doesn't meet your requirements, but you keep on trying to refer its case as to showing that DDD doesn't halt if not aborted, but this DDD is never given to any of the Case 1 HHHs.
Your trying to claim that DDD doesn't include the HHH is just a LIE, as it must to be a program, so if it doesn't, you can't actually emulate it past the first 4 steps.

 Likewise when you are no longer hungry after getting
something to eat this conclusively proves that you never
were hungry thus never needed to eat.

Red Herring.

 Are you really sure that you want to swear your allegiance
to the father of lies?
 

I don't, but you sure seem to have.
For instance, are you still holding to your lie that the representation of DDD as a FULL program doesn't include the code of HHH?
Or is it a LIE that HHH is actually defined as a decider for the behavior of a program?
Or is it a LIE that you are following the requirement of Computation Theory (which I think you just don't know). Note, not knowing doesn't make it a lie, but could be an honest mistake, repeating them after being told you are wrong, makes it a lie by the reckless disregard of the truth.