@MSGID: AsA.238356@fx18.iad>
b7cc9848
@REPLY: 1@dont-email.me> 5f1a5d0e
@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>
1@dont-email.me>
@RFC-Message-ID:
AsA.238356@fx18.iad>
@TZUTC: -0400
@PID: Mozilla Thunderbird
@TID: FIDOGATE-5.12-ge4e8b94
On 8/27/23 3:31 PM, olcott wrote:
> On 8/27/2023 12: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.
>>
> 
> When a termination analyzer is required to provide the halt status or an
> input that deliberately contradicts whatever Boolean value that this
> termination analyzer returns the halting problem merely mirrors the Liar
> Paradox.

Nope, and shows your ignorance.

To be applicable to the problem, your "Termination Analyzer" must be an 
actual program, and thus it must give an actual answer.

IF H is this "Termination Analyzer" then it also must be an actual 
program an d thus gives an actual specific answer for any specific input.

The input D, built on the program H, WILL be an actual program (since H 
is) and thus is in the domain of the Analyzer, since the problem 
statement says for ANY program.

The question the program is to answer is "Does the program represented 
by the input to the decider Halt when run?"

Since you stipulate that H(D,D) WILL return 0 (and incorrectly claim 
this to be correct) a simple analysis of the code of D shows that it 
WILL halt. in part BECAUSE H(D,D) return 0.

Thus, the CORRECT answer is Halt.

THe answer given by H was Non-Halting, and thus is WRONG.

> 
> The Liar Paradox cannot be correctly resolved to a value of True or
> False only because it is semantically unsound because it is self-
> contradictory.

But since the answer to the question HAS an actual answer, it isn`t an 
equivalent to the liar`s paradox.

Your alternate quesition, what can be build an H to return for this 
case, IS an equivalent to the liars paradox, which doesn`t make the 
original question of the Halting Problem invalid, it just shows that we 
can`t actually build such a machine (at least by the method you are 
investigating) and thus just provides support (or proves if you clean 
things up a bit) that the Halting Function is non-computable and thus we 
can not make a program that answers the Halting Problem.

> 
> Thus the inability of a termination analyzer to provide a correct
> Boolean return value is analogous to a CAD system`s inability to
> correctly draw a square circle. Thus this interpretation of the halting
> problem is merely an artificial contrivance with no actual merit.

So, you AGREE that it is impossible to build a program to answer the 
Halting Problem?

Then way do you say you have disproved the very thing you agreed with?

You seem to be confused.


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