@MSGID: U3w1.331451@fx09.iad>
10ebd996
@REPLY: 1@dont-email.me> f82d9a9b
@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> 1@dont-email.me> 1@dont-email.me>
@RFC-Message-ID:
U3w1.331451@fx09.iad>
@TZUTC: -0400
@PID: Mozilla Thunderbird
@TID: FIDOGATE-5.12-ge4e8b94
On 8/27/23 1:13 PM, olcott wrote:
> On 8/27/2023 10:00 AM, olcott wrote:
>> On 8/25/2023 1:48 PM, olcott wrote:
>>> A pair of C functions are defined such that D has the halting problem
>>> proof`s pathological relationship to simulating termination analyzer H.
>>> When it is understood that D correctly simulated by H (a) Is the
>>> behavior that H must report on and (b) Cannot possibly terminate
>>> normally then it is understood that D is correctly determined to be non-
>>> halting.
>>>
>>> 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.
>>>
>>> For any program H that might determine whether programs halt, a
>>> "pathological" program D, called with some input, can pass its own
>>> source and its input to H and then specifically do the opposite of what
>>> H predicts D will do. No H can exist that handles this case.
>>> https://en.wikipedia.org/wiki/Halting_problem
>>>
>>> "A decision problem is a yes-or-no question on an infinite set of 
>>> inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition
>>>
>>> Can D correctly simulated by H terminate normally?
>>> The x86utm operating system: https://github.com/plolcott/x86utm
>>> is based on an open source x86 emulator. x86utm enables one C function
>>> to execute another C function in debug step mode.
>>>
>>> // 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)
>>> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>
>>> *Simulation invariant*
>>> D correctly simulated by H cannot possibly reach past its own line 06.
>>>
>>> H correctly determines that D correctly simulated by H cannot possibly
>>> terminate normally on the basis that H recognizes a dynamic behavior
>>> pattern equivalent to infinite recursion. H returns 0 this basis.
>>>
>>> *ADDENDUM*
>>>
>>> (1) The source-code of H and D conclusively proves that D correctly
>>> simulated by H cannot possibly terminate normally.
>>>
>>> *THIS IS THE PART THAT EVERYONE LIES ABOUT*
>>> (2) The correct simulation of D by H must include the fact that
>>> D would continue to call H until stack overflow crash unless H
>>> aborts its simulation of D.
>>>
>>> (3) (2) Means that D is correctly simulated by H and this correctly 
>>> simulated D is non-halting.
>>>
>>> (4) "A decision problem is a yes-or-no question on an infinite set
>>> of inputs" https://en.wikipedia.org/wiki/Decision_problem#Definition
>>> This means that the behavior of non-inputs is not allowed to be
>>> considered.
>>>
>>
>> If H ignores reality (not a good idea) and [as most of my reviewers
>> believe] makes pretend that it is simulating D(D) directly executed in
>> main() then the actual D that H is actually simulating will crash from
>> stack overflow because H will never stop simulating D.
>>
>> This conclusively proves that D is correct to abort its simulation and
>> return 0 indicating that D correctly simulated by H cannot possibly
>> terminate normally.
>>
> 
> (5) Of the infinite set of every possible H where D is correctly 
> simulated by H there are only a THREE categories of possible
> behaviors for H:  (1)(a), (1)(b) and (2)
> 
> (1) Abort its simulation of D after a finite number of steps:
>     (a) Return 0 indicating that D correctly simulated by H cannot
>         possibly terminate normally.
> 
>     (b) Return 1 indicating that D correctly simulated by H will
>         terminate normally.
> 
> (2) Never abort its simulation of D.
> 
> Anyone having a sufficient knowledge of C can correctly determine which
> of these options are incorrect on the basis of the source-code of D.

And ALL of your H`s are shown to be incorrect for the input they were given.

Remember, each was given a DIFFERENT input, as you are giving it the D 
built on IT, so each is a DIFFERENET input

So, you just proved what you claimed to refute, because you are actually 
THAT STUPID.

Problem Statement: H needs to return correct answer that corresponds to 
the actual behavior of the machine represented by its input when it is run.

Class 1a:
H aborts its simulation after some time and returns 0 (saying non-halting)
By the definition of D, that D, when actually run, will get that 0 
returned and then HALT.

So H was wrong.

Class 1b:
H aborts its simulation after some time and returns 1 (Saying Halting).
By the definition of D, that D, when actually run, will get that 1 
returned to it, and then go into an infinite loop, and never halt.

So H was wrong.

Class 2:

H never aborts is simulation of D, and thus gets stuck in an infinite 
recursion and thus never gives an answer.

So H is wrong.


Thus, you have shown that for EVERY POSSIBLE H, built by you system, 
NONE of them gave the correct answer for its input.

You are just proving that you are lying about working on the problem 
that you claim you are, likely because you are just too stupid to 
understand it.


You seem to think that one program can be all of the above, and its 
input is also all of the above.

That shows you don`t understand what a "program" is.

YOU FAIL.

> 
>>
>> *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
>>
> 

--- 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