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:03:07 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <v19h9b$5asr$17@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>
 <v18vni$23glj$1@dont-email.me> <v19252$5asr$14@i2pn2.org>
 <v198jn$253i2$1@dont-email.me> <v199bk$5asr$15@i2pn2.org>
 <v19g2g$2aufj$4@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:03:07 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="175003"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
X-Spam-Checker-Version: SpamAssassin 4.0.0
In-Reply-To: <v19g2g$2aufj$4@dont-email.me>
Content-Language: en-US
Bytes: 7122
Lines: 160

On 5/5/24 10:42 PM, olcott wrote:
> On 5/5/2024 7:47 PM, Richard Damon wrote:
>> On 5/5/24 8:35 PM, olcott wrote:
>>> On 5/5/2024 5:44 PM, Richard Damon wrote:
>>>> On 5/5/24 6:03 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.
>>>>>
>>>>> H that simulates the D that calls H(D,D) will simulate to
>>>>> 1 ∞ steps of D.
>>>>
>>>> Nope, when your H simulates the call to H(D,D) inside D, your H does 
>>>> NOT simulated that H, but instead simultes the machine that that 
>>>> machine would be simulating.
>>>>
>>>
>>> I am not talking about my H
>>> I am talking about every element of the infinite set of
>>> H/D pairs where D is simulated by the same H that D calls.
>>> I will repeat this endlessly to your every post until you get it
>>
>> So, what does an infinite set of programs and an infinte set of inputs 
>> do?
>>
> 
> I am talking about every element of the infinite set of
> H/D pairs where D is simulated by the same H that D calls.
> 
> The 1st H simulates 1 steps of D
> The 2nd H simulates 2 steps of D
> The 3rd H simulates 3 steps of D
> ...
> The 5,000,000,000 H simulates 5,000,000,000 steps of D
> ...
> All the way up to H that simulates ∞ steps of D
> 
> None of these D(D) simulated by the H that D(D) calls
> ever reach past their own line 03.

Then they aren't doing it right.

In particular, I suspect they aren't simulation the CALL H instruction 
right.

Note, it DOESN'T go directly from "Call H" to a new layer of simulation 
of D(D).

Not unless you have somehow redefined what simulation means and not 
mentioned that.

This seems to be a common problem with you.

> 
>> If you don't run each of those H's individually on its D, what else do 
>> you mean to do?
>>
> 
> When we can directly see that every element of an infinite set
> has a property of never reaching past its own line 03 then we
> know that no D(D) ever reaches its own line 06 and halts.
> 
>  From this we know that every input D(D) that calls H(D,D) and
> is simulated by H specifies non halting behavior to H(D,D).

Nope, I described how an H can exist that directly and correctly 
simulated ALL o fthe instructions that is sees while simulating D(D) 
while doing it RIGHT.

> 
> 
>> I think you need to figure out how your computation model actua;lly 
>> works,
>>
>> It seems to be just a bunch of gobbledygook to me.
>>
>> It seems about as bad as WM and his dark numbers.
>