Re: HHH maps its input to the behavior specified by it --- reaches its halt state --- Which DDD does if HHH(DDD) returns and answer, which it does since it is a decider.

On 8/9/24 11:15 PM, olcott wrote:

On 8/9/2024 9:56 PM, Richard Damon wrote:

On 8/9/24 10:43 PM, olcott wrote:

On 8/9/2024 9:35 PM, Richard Damon wrote:

On 8/9/24 10:24 PM, olcott wrote:

On 8/9/2024 8:54 PM, Richard Damon wrote:

On 8/9/24 9:52 PM, olcott wrote:

On 8/9/2024 8:46 PM, Richard Damon wrote:

On 8/9/24 9:25 PM, olcott wrote:

On 8/9/2024 8:05 PM, Richard Damon wrote:

On 8/9/24 8:52 PM, olcott wrote:

>
When we look at every HHH that can possibly exist then
we see that DDD correctly emulated by each one of these
cannot possibly reach its "return" instruction halt state.

>
But ONLY ONE of those actuallu "correctly emulates" the input, and that one isn't a decider.
>

>
In other words you are trying to keep getting away
with the bald-faced lie that when HHH correctly
emulates N instructions of DDD (where N > 0) that
it did not correctly emulate any instructions of DDD.
>
*Give it up you lost you are stuck in repeat mode*
*Give it up you lost you are stuck in repeat mode*
*Give it up you lost you are stuck in repeat mode*
>

>
So, I guess you don't understand English.
>
Where did I say that simulating N instructions correctly is not simulating ANY instructions correctly.
>

>
*Shown above*
"But ONLY ONE of those actuallu "correctly emulates" the input..."
>

>
Right, becuase to correctly emulate, you need to correct emulate EVERY instruction, not just some of them.
>

>
So you defining whole notion simulating termination analyzers
as incorrect even though professor Sipser has agreed that the
simulation need not be complete.

>
No, they just need to do the job right.
>
But it needs to prove that the CORRECT SIMULATION, which would be complete, doesn't ever reach a final state. T

>
void DDD()
{
   HHH(DDD);
   return;
}
>
You already know that a complete simulation of DDD
by a pure x86 emulator cannot possibly reach its
"return" instruction halt state.

>
Of course it can. as long as it isn't HHH, and the HHH that DDD was paired with gives an answer.
>
Your problem is thinking the only simulator allowed is HHH.
>

 When HHH reports that its input cannot possibly reach
the "return" instruction halt state of this input it
is correct. HHH only computes the mapping from its input
to the behavior that this input specifies.

No, the "input" is the full program, and even you have admitted that when that program is run directly it halts.
Thus, the "mapping" it NEEDS to try to compute says that input Halts.
The fact that HHH aborts its partial emulation before it gets there doesn't mean that the program doesn't get there.
Thus, HHH reports incorrectly, because its programmer doesn't understand that the code for DDD actually included the code for HHH, and thus HHH must treat that call like a call to itself, and thus know that if it will return (which it will if it is a decider), then the code it is simulating will return from the call.

 All of your every attempt to rebut this were anchored
in the strawman deception. I am beginning to have no
doubts that you are a deceiver. For your soul's sake
I hope this is an ADD issue and not willful deception.
 

No, you are just showing you don't understand the difference between a partial emulation of a program and the full behavior of it. OR maybe what the original question was asking.
This seems to be rooted in you inability to distinguish fantasy from reality.
Sorry, you are just proving to the world how stupid you are, and that you can't see how stupid you are, which is the worse type of stupid.