Path: ...!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: Tue, 7 May 2024 10:40:32 -0500
Organization: A noiseless patient Spider
Lines: 133
Message-ID: <v1di1h$3b2m5$1@dont-email.me>
References: <v18e32$1vbql$1@dont-email.me> <v1avuv$2lks2$1@dont-email.me>
 <v1b7gl$2ndka$1@dont-email.me> <v1cla9$34iis$1@dont-email.me>
 <v1d2mi$9f72$11@i2pn2.org>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 07 May 2024 17:40:34 +0200 (CEST)
Injection-Info: dont-email.me; posting-host="1fe47412d5222aa086f42d5af46fe483";
	logging-data="3508933"; mail-complaints-to="abuse@eternal-september.org";	posting-account="U2FsdGVkX1/SOx2nWEnnPr0cob2pw4qH"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:Ogzp5LL6Mki9MI8bES7M+Y+pZO4=
In-Reply-To: <v1d2mi$9f72$11@i2pn2.org>
Content-Language: en-US
Bytes: 5780

On 5/7/2024 6:18 AM, Richard Damon wrote:
> On 5/7/24 3:30 AM, Mikko wrote:
>> On 2024-05-06 18:28:37 +0000, olcott said:
>>
>>> On 5/6/2024 11:19 AM, Mikko wrote:
>>>> On 2024-05-05 17:02:25 +0000, olcott said:
>>>>
>>>>> 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.
>>>>>
>>>>> 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.
>>>>>
>>>>> 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.
>>>>
>>>> When you say "every H/D pair" you should specify which set of pairs
>>>> you are talking about. As you don't, your words don't mean anything.
>>>>
>>>
>>> Every H/D pair in the universe where D(D) is simulated by the
>>> same H(D,D) that D(D) calls. This involves 1 to ∞ steps of D
>>> and also includes zero to ∞ recursive simulations where H
>>> H simulates itself simulating D(D).
>>
>> "In the universe" is not a set. In typical set theories like ZFC there
>> is no universal set.
> 

This template defines an infinite set of finite string H/D pairs where 
each D(D) that is simulated by H(D,D) also calls this same H(D,D).

These H/D pairs can be enumerated by the one to ∞ simulated steps of D 
and involve zero to ∞ recursive simulations of H simulating itself 
simulating D(D). Every time Lines 1,2,3 are simulated again defines
one more level of recursive simulation.

1st element of H/D pairs 1 step  of D  is simulated by H
2nd element of H/D pairs 2 steps of D are simulated by H
3rd element of H/D pairs 3 steps of D are simulated by H

4th element of H/D pairs 4 steps of D are simulated by H
this begins the first recursive simulation at line 01

5th element of H/D pairs 5 steps of D are simulated by
next step of the first recursive simulation at line 02

6th element of H/D pairs 6 steps of D are simulated by
last step of the first recursive simulation at line 03

7th element of H/D pairs 7 steps of D are simulated by H
this begins the second recursive simulation at line 01

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 01
Line 02
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.

The key thing to note is that no D simulated by any H ever reaches
its own line 06 and halts. This means that the input to H(D,D) is
ALWAYS non-halting.

> 
> No, it shows that he is just thinking of Nieve set theory, you know, the 
> one that was proven broken.
> 
>>
>> Usually the best way to introduce a set of pairs is that first two
>> sets are specified and then a rule that selects some pairs from
>> the Cartesian product of those two sets.
>>
>> In the current case the first set could be the set programs that
>> take two input values (possibly of some specific type) and returns
>> a Boolean value, and the second set could be programs that take
>> one input value (of the same type as the programs in the first set).
>> Or whatever best serves your purposes.
>>
> 

-- 
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer