Warning: mysqli::__construct(): (HY000/1203): User howardkn already has more than 'max_user_connections' active connections in D:\Inetpub\vhosts\howardknight.net\al.howardknight.net\includes\artfuncs.php on line 21
Failed to connect to MySQL: (1203) User howardkn already has more than 'max_user_connections' active connectionsPath: ...!weretis.net!feeder9.news.weretis.net!news.nk.ca!rocksolid2!i2pn2.org!.POSTED!not-for-mail
From: Richard Damon
Newsgroups: comp.theory,sci.logic
Subject: Re: Every D(D) simulated by H presents non-halting behavior to H
Date: Mon, 6 May 2024 06:33:58 -0400
Organization: i2pn2 (i2pn.org)
Message-ID:
References:
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 6 May 2024 10:33:58 -0000 (UTC)
Injection-Info: i2pn2.org;
logging-data="244673"; 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:
Content-Language: en-US
Bytes: 11351
Lines: 283
On 5/6/24 12:14 AM, olcott wrote:
> On 5/5/2024 10:08 PM, Richard Damon wrote:
>> 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.
>>
>
> Proving that your trivial decider is shit because it got factorial wrong.
Right, just like H is because it gets D(D) wrong.
It is JUST a correct about factorial as H is about D, which shows that
the issue is the DEFINITION is SHIT (or POOP)
>
>> 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;
>>> }
>>>
========== REMAINDER OF ARTICLE TRUNCATED ==========