@MSGID: uEkc.64390@fx35.iad>
6ad82c37
@REPLY: 1@dont-email.me> da83a11c
@REPLYADDR Richard Damon
<Richard@Damon-Family.org>
@REPLYTO 2:5075/128 Richard Damon
@CHRS: CP866 2
@RFC: 1 0
@RFC-References: 3@dont-email.me>
1@dont-email.me>
@RFC-Message-ID:
uEkc.64390@fx35.iad>
@TZUTC: -0400
@PID: Mozilla Thunderbird
@TID: FIDOGATE-5.12-ge4e8b94
On 8/23/23 12:00 AM, olcott wrote:
> When it is understood that D correctly simulated by H is the behavior
> that H must report on then the halting problem`s otherwise impossible
> input is correctly determined to be non-halting.

You STILL don`t get it do you!!

Your H DOESN`T correctly simulate its input, thus you are just showing 
yourself to be a STUPID LIAR.

You don`t even seem to understand that programs do what they are 
actually programmed to do, not just what you want them to do.

> 
> We can know that D correctly simulated by H must have different behavior
> than D(D) directly executed in main() because we can see (in its
> execution trace shown below) exactly how the pathological relationship
> between D and H changes the behavior of D relative to H.

How? Sinrr H DOESN`T correctly simulate its input.

We can tell that as its simulation differs from the ACTUAL Correct 
Simulation of this input that you previously posted.

So, it seems that you thing two things that are different can be called 
the same.


> 
> *Can D correctly simulated by H terminate normally*

WHO CARES?

Since H doesn`t actually correctly simulate its input, it doesn`t matter 
what some other machine that goes by the name H does.

This is just like your "famous" questions about arresting the twin.

You are just showing how stupid you are.


> The x86utm operating system based on an open source x86 emulator. This
> system enables one C function to execute another C function in debug
> step mode.

Yes, and that shows that the COPRRECT simulation of the input to H stops.

Thus you are just a pathetic liar to say that H`s correct simulation 
show it doesn`t

> 
> // The following is written in C
> //
> 01 typedef int (*ptr)(); // pointer to int function
> 02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
> 03
> 04 int D(ptr x)
> 05 {
> 06   int Halt_Status = H(x, x);
> 07   if (Halt_Status)
> 08     HERE: goto HERE;
> 09   return Halt_Status;
> 10 }
> 11
> 12 void main()
> 13 {
> 14   H(D,D);
> 15 }
> 
> *Execution Trace*
> Line 14: main() invokes H(D,D);
> 
> *keeps repeating* (unless aborted)

Nope, the H that D calls aborts its simulation as that is what itis 
programmed to do.

You are just admitting to being a liar.

> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)

Nope. LIES.

> 
> *Simulation invariant*
> D correctly simulated by H cannot possibly reach past its own line 06.

So?

An H that correctly simulates the D built on it never answers, so fails 
to be a decider.

> 
> 
> *Termination Analyzer H is Not Fooled by Pathological Input D*
https://www.researchgate.net/publication/369971402_Termination_Analyzer_H_is_Not
_Fooled_by_Pathological_Input_D


Just your proof of your stupidity.
> 

--- Mozilla Thunderbird
 * Origin: Forte - www.forteinc.com (2:5075/128)
SEEN-BY: 5001/100 5005/49 5015/255 5019/40 5020/715
848 1042 4441 12000
SEEN-BY: 5030/49 1081 5058/104 5075/128
@PATH: 5075/128 5020/1042 4441