Path: ...!news.mixmin.net!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: olcott <polcott333@gmail.com>
Newsgroups: comp.theory,sci.logic
Subject: Re: Every D(D) simulated by H presents non-halting behavior to H
Date: Sun, 5 May 2024 21:33:11 -0500
Organization: A noiseless patient Spider
Lines: 241
Message-ID: <v19fh7$2aufj$1@dont-email.me>
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>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 06 May 2024 04:33:12 +0200 (CEST)
Injection-Info: dont-email.me; posting-host="2ca33c147f4bf21714ceb8650be68951";
	logging-data="2456051"; mail-complaints-to="abuse@eternal-september.org";	posting-account="U2FsdGVkX1/Xl9CFfUJxqmuVgxFQ4PDP"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:ZQrBejgy7Cfn32JDYnErA323ck0=
Content-Language: en-US
In-Reply-To: <v194kl$5asq$8@i2pn2.org>
Bytes: 9471

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

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.

>>
>> On 5/1/2024 7:28 PM, Richard Damon wrote:
>>  > On 5/1/24 11:51 AM, olcott wrote:
>>  >> *I HAVE SAID THIS AT LEAST 10,000 TIMES NOW*
>>  >> Every D simulated by H that cannot possibly stop running unless
>>  >> aborted by H does specify non-terminating behavior to H. When
>>  >> H aborts this simulation that does not count as D halting.
>>  >
>>  > Which is just meaningless gobbledygook by your definitions.
>>  >
>>  > It means that
>>  >
>>  > int H(ptr m, ptr d) {
>>  > return 0;
>>  > }
>>  >
>>  > is always correct, because THAT H can not possible simulate
========== REMAINDER OF ARTICLE TRUNCATED ==========