Path: ...!weretis.net!feeder9.news.weretis.net!news.nk.ca!rocksolid2!i2pn2.org!.POSTED!not-for-mail
From: Richard Damon <richard@damon-family.org>
Newsgroups: comp.theory,sci.logic
Subject: Re: Every D(D) simulated by H presents non-halting behavior to H
Date: Sun, 5 May 2024 23:08:57 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <v19hk9$5asr$19@i2pn2.org>
References: <v18e32$1vbql$1@dont-email.me> <v18f9e$5asq$4@i2pn2.org>
 <v18lj3$20ukn$1@dont-email.me> <v18sq6$5asr$9@i2pn2.org>
 <v18tov$22tig$1@dont-email.me> <v18v9q$5asr$13@i2pn2.org>
 <v192q4$2436r$1@dont-email.me> <v194kl$5asq$8@i2pn2.org>
 <v19fh7$2aufj$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 6 May 2024 03:08:57 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="175003"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
In-Reply-To: <v19fh7$2aufj$1@dont-email.me>
Content-Language: en-US
X-Spam-Checker-Version: SpamAssassin 4.0.0
Bytes: 10374
Lines: 267

On 5/5/24 10:33 PM, olcott wrote:
> On 5/5/2024 6:27 PM, Richard Damon wrote:
>> On 5/5/24 6:56 PM, olcott wrote:
>>> On 5/5/2024 4:56 PM, Richard Damon wrote:
>>>> On 5/5/24 5:30 PM, olcott wrote:
>>>>> On 5/5/2024 4:13 PM, Richard Damon wrote:
>>>>>> On 5/5/24 3:10 PM, olcott wrote:
>>>>>>> On 5/5/2024 12:22 PM, Richard Damon wrote:
>>>>>>>> On 5/5/24 1:02 PM, olcott wrote:
>>>>>>>>> The x86utm operating system: https://github.com/plolcott/x86utm 
>>>>>>>>> enables
>>>>>>>>> one C function to execute another C function in debug step mode.
>>>>>>>>> Simulating Termination analyzer H simulates the x86 machine 
>>>>>>>>> code of its
>>>>>>>>> input (using libx86emu) in debug step mode until it correctly 
>>>>>>>>> matches a
>>>>>>>>> correct non-halting behavior pattern proving that its input 
>>>>>>>>> will never
>>>>>>>>> stop running unless aborted.
>>>>>>>>
>>>>>>>> Except that the pattern it uses is incorrect, since H(D,D) using 
>>>>>>>> this "pattern" says that D(D) will not halt, where, when main 
>>>>>>>> calls D(D), it does return/halt, so H is just incorrect.
>>>>>>>>
>>>>>>>>
>>>>>>>>>
>>>>>>>>> Can D correctly simulated by H terminate normally?
>>>>>>>>> 00 int H(ptr x, ptr x)  // ptr is pointer to int function
>>>>>>>>> 01 int D(ptr x)
>>>>>>>>> 02 {
>>>>>>>>> 03   int Halt_Status = H(x, x);
>>>>>>>>> 04   if (Halt_Status)
>>>>>>>>> 05     HERE: goto HERE;
>>>>>>>>> 06   return Halt_Status;
>>>>>>>>> 07 }
>>>>>>>>> 08
>>>>>>>>> 09 int main()
>>>>>>>>> 10 {
>>>>>>>>> 11   H(D,D);
>>>>>>>>> 12 }
>>>>>>>>>
>>>>>>>>> *Execution Trace*
>>>>>>>>> Line 11: main() invokes H(D,D);
>>>>>>>>>
>>>>>>>>> *keeps repeating* (unless aborted)
>>>>>>>>> Line 03: 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 03.
>>>>>>>>
>>>>>>>> Nope, PROVEN WRONG AND THE PROOF IGNORED, PO have even claimed 
>>>>>>>> that it would be trivial to show the error in the proof, but 
>>>>>>>> hasn't done it, showing that he doesn't actually have an answer 
>>>>>>>> to the refutation, and thus by just repeating a statment that is 
>>>>>>>> know to at least potentially have a problem as if it was just 
>>>>>>>> clearly true is just a pathological lie.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> The above execution trace proves that (for every H/D pair of the
>>>>>>>>> infinite set of H/D pairs) each D(D) simulated by the H that 
>>>>>>>>> this D(D)
>>>>>>>>> calls cannot possibly reach past its own line 03.
>>>>>>>>
>>>>>>>> Except that the proof shows that you are not smart enough to 
>>>>>>>> think of some of the ways arround the problem (even though those 
>>>>>>>> methods were discussed a long time back)
>>>>>>>>
>>>>>>>
>>>>>>> The above execution trace proves the behavior of each D simulated by
>>>>>>> each H of the elements of the infinite set of H/D pairs where this D
>>>>>>> calls that H.
>>>>>>
>>>>>> Nope, your problem is you stop simulating at the call to H and 
>>>>>> then resort to incorrect logic to try to figure out what happens 
>>>>>> next.
>>>>>>
>>>>>
>>>>> I have to usually tell you the exactly same thing several
>>>>> hundreds of times before you notice that I ever said it once.
>>>>>
>>>>> We are talking about the infinite set of H/D pairs where
>>>>> D is simulated by the same H that D calls.
>>>>>
>>>>> We are talking about the infinite set of H/D pairs where
>>>>> D is simulated by the same H that D calls.
>>>>>
>>>>> We are talking about the infinite set of H/D pairs where
>>>>> D is simulated by the same H that D calls.
>>>>>
>>>>> We are talking about the infinite set of H/D pairs where
>>>>> D is simulated by the same H that D calls.
>>>>>
>>>>> Elements of this set of H/D pairs simulate from 1 to infinite steps 
>>>>> of D and each one of them does this in an infinite number of 
>>>>> different ways.
>>>>
>>>> (this is wrong, as EACH H only simulates its one D one way, so each 
>>>> one doesn't simulate in an infinite number of ways, but I think you 
>>>> are just failing at grammer here
>>>>
>>>>>
>>>>> There are an infinite number of different ways for H to simulate
>>>>> 1 step of D.
>>>>
>>>> So?
>>>>
>>>
>>> *Your system clock is off you responded to my 5:30 post at 4:56*
>>
>> No, you don't seem to understand about TIME ZONES.
>>
>> I guess that is too advanced for you.
>>
>>>
>>>> The TWO methods I posted still follow that description and show how 
>>>> H can simulate past the point that you say NO H can get past,
>>>>
>>>
>>> *This has already been proven to be dishonest*
>>
>> Nope, you seem to be stuck on the example below, which is not either 
>> of the two methods 
> 
> Give me a freaking time/date stamp otherwise
> everyone will know that you are lying.
> 
>> I showed how to simulate past the call, but showed how if your 
>> statement WAS made to be correct, how it implies a trivial decider 
>> could also be considered correct.
>>
> 
> There is no trivial decider that correctly recognizes recursive 
> simulation and correctly decides these inputs

My trivial decider decided all of them as non-halting.

now, since D(D) Halts, just like factorial(5), why do you say that 
H(D,D) is correct to say it doesn't?

> 
> void Infinite_Recursion(u32 N)
> {
>    Infinite_Recursion(N);
> }
> 
> void Infinite_Loop()
> {
>    HERE: goto HERE;
> }
> 
> int factorial(int n)
> {
>    if (n >= 1)
>      return n*factorial(n-1);
>    else
>      return 1;
> }
> 
>> I have mentioned this several times, but I guess you can't understand 
>> basic English.
>>
> 
> Give me a freaking time/date stamp otherwise
> everyone will know that you are lying.

And I'bve told you what you need to say to get that.

If you are so sure I didn't, it doesn't cost you anything to make the 
promise.

If you aren't sure, you need to admit that you claim things without 
actually knowing them, and promise to stop doing that.
========== REMAINDER OF ARTICLE TRUNCATED ==========