COMP.THEORY-------------- < Пред. | След. > -- < @ > -- < Сообщ. > -- < Эхи > --
 Nп/п : 72 из 100
 От   : Richard Damon                       2:5075/128        27 авг 23 12:28:47
 К    : olcott                                                27 авг 23 19:31:03
 Тема : Re: Termination Analyzer H is Not Fooled by Pathological Input D (bette
----------------------------------------------------------------------------------
                                                                                 
@MSGID: <3RKGM.490025$U3w1.279288@fx09.iad>
e2453fe8
@REPLY: 1@dont-email.me> 16e113cf
@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>
@RFC-Message-ID:
<3RKGM.490025$U3w1.279288@fx09.iad>
@TZUTC: -0400
@PID: Mozilla Thunderbird
@TID: FIDOGATE-5.12-ge4e8b94
So, you STILL don`t understand that a program does what it is actually 
programmed to do, and nothing else,

And to talk about what a program "would" have done if, as something 
different than what it actually does, is just a LIE.

H can`t make a correct decision based on behavior of a DIFFERENT program 
given a DIFFERENT input and say this answer applies here.

The question that H MUST answer, is "Does the machine represented by its 
input Halt?"

Since H(D,D) returns 0, it is shown that D(D) Halts, and thus the 
CORRECT answer for a Halt Decider is Halting, so H is just WRONG.

You are just proving yourself to be an ignorant pathological lying idiot 
that just doesn`t know what he is talking about.

YOU FAIL.

Just repeating your same claim over and over just proves you are INSANE, 
as well as Stupid, and incapable of learning, and can`t actually do any 
real logic.


On 8/27/23 11: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.


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



   GoldED+ VK   │                                                 │   09:55:30    
                                                                                
В этой области больше нет сообщений.

Остаться здесь
Перейти к списку сообщений
Перейти к списку эх