Path: ...!weretis.net!feeder9.news.weretis.net!i2pn.org!i2pn2.org!.POSTED!not-for-mail
From: Richard Damon <richard@damon-family.org>
Newsgroups: comp.theory
Subject: Re: Every D(D) simulated by H presents non-halting behavior to H ###
Date: Wed, 29 May 2024 19:47:21 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <v38eq9$2foi0$4@i2pn2.org>
References: <v18e32$1vbql$1@dont-email.me> <v1vsru$7eqc$1@dont-email.me>
 <v21r4i$otc2$2@dont-email.me> <v22k4b$umr4$1@dont-email.me>
 <v24oah$1h4u3$1@dont-email.me> <v256fc$1kais$1@dont-email.me>
 <v27d05$25ga0$1@dont-email.me> <v2838r$29rd7$1@dont-email.me>
 <v2a8th$2ps09$1@dont-email.me> <v2ahqc$2qvr9$1@dont-email.me>
 <v2cb5s$39fvg$1@dont-email.me> <v2crk0$3cifp$1@dont-email.me>
 <v2cvuo$3dfkm$1@dont-email.me> <v2i921$jvcs$5@dont-email.me>
 <v2k7fe$12vjm$1@dont-email.me> <v2l0q8$17mu1$1@dont-email.me>
 <v2n4f7$1ms87$1@dont-email.me> <v2nfma$1or9h$4@dont-email.me>
 <v2pkqq$28mg0$1@dont-email.me> <v2qhr2$2dpfr$6@dont-email.me>
 <v2s6kk$2q0pf$1@dont-email.me> <v2skde$2s65h$1@dont-email.me>
 <v2uthd$3bjch$1@dont-email.me> <v2vdkp$3dtct$3@dont-email.me>
 <v2vned$3fl3r$1@dont-email.me> <v2vp8f$3g0m3$1@dont-email.me>
 <v31f7s$3ukf5$1@dont-email.me> <v3236b$29pd$1@dont-email.me>
 <v340en$gbvn$1@dont-email.me> <v34q6t$krgu$1@dont-email.me>
 <v36ra1$12u78$1@dont-email.me> <v379tc$159q4$3@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Wed, 29 May 2024 23:47:21 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="2613824"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
In-Reply-To: <v379tc$159q4$3@dont-email.me>
Content-Language: en-US
X-Spam-Checker-Version: SpamAssassin 4.0.0
Bytes: 7483
Lines: 143

On 5/29/24 9:17 AM, olcott wrote:
> On 5/29/2024 4:08 AM, Mikko wrote:
>> On 2024-05-28 14:37:15 +0000, olcott said:
>>
>>> On 5/28/2024 2:17 AM, Mikko wrote:
>>>> On 2024-05-27 13:52:09 +0000, olcott said:
>>>>
>>>>> On 5/27/2024 3:11 AM, Mikko wrote:
>>>>>> On 2024-05-26 16:50:21 +0000, olcott said:
>>>>>>
>>>>>
>>>>> <snip>
>>>>> So that: *Usenet Article Lookup*
>>>>> http://al.howardknight.net/
>>>>> can see the whole message now that
>>>>> *the Thai spammer killed Google Groups*
>>>>>
>>>>> typedef int (*ptr)();  // ptr is pointer to int function in C
>>>>> 00       int H(ptr p, ptr i);
>>>>> 01       int D(ptr p)
>>>>> 02       {
>>>>> 03         int Halt_Status = H(p, p);
>>>>> 04         if (Halt_Status)
>>>>> 05           HERE: goto HERE;
>>>>> 06         return Halt_Status;
>>>>> 07       }
>>>>> 08
>>>>> 09       int main()
>>>>> 10       {
>>>>> 11         H(D,D);
>>>>> 12         return 0;
>>>>> 13       }
>>>>>
>>>>>>> When we see that D correctly simulated by pure simulator H would 
>>>>>>> remain
>>>>>>> stuck in recursive simulation then we also know that D never 
>>>>>>> reaches its
>>>>>>> own line 06 and halts in less than an infinite number of correctly
>>>>>>> simulated steps.
>>>>>>
>>>>>> Which means that H never terminates. You said that by your definition
>>>>>> a function that never terminates is not a pure function. Therefore
>>>>>> H, if it exists, is not a pure function, and the phrase "pure 
>>>>>> function
>>>>>> H" does not denote.
>>>>>
>>>>> *I should have said that more clearly*
>>>>> *That is why I need reviewers*
>>>>
>>>> What is said here has little significance. You should ask reviewer's
>>>> comments about your working draft that you maintain in GitHub or some
>>>> other web site. And you should update that draft when a reviewer finds
>>>> some something wrong or unclear.
>>>>
>>>>> *This is STEP ONE of my four step proof*
>>>>> STEP TWO applies these same ideas to the Peter Linz HP proof.
>>>>> STEP THREE shows how the Linz Ĥ.H sees the behavior of its recursive
>>>>>       simulations.
>>>>> STEP FOUR shows why the behavior of the INPUT is the correct basis.
>>>>
>>>> When discussing individual steps of a proof draft you shold start
>>>> at the last step.
>>>
>>> I have been at this for twenty years.
>>> Ben Bacarisse has spoken with me for 15 of those years.
>>>
>>> What I found out is that exactly one point of one step
>>> must be pursued until complete closure of that one point
>>> of that one step.
>>
>> How long do you think it takes to cover them all, starting
>> from the first?
>>
>> How long do you think it would take, starting from the last?
>>
> 
> The first point was closed in less than one hour with each of
> four people that were not playing head games.
> 
> typedef int (*ptr)();  // ptr is pointer to int function in C
> 00       int H(ptr p, ptr i);
> 01       int D(ptr p)
> 02       {
> 03         int Halt_Status = H(p, p);
> 04         if (Halt_Status)
> 05           HERE: goto HERE;
> 06         return Halt_Status;
> 07       }
> 08
> 09       int main()
> 10       {
> 11         H(D,D);
> 12         return 0;
> 13       }
> 
> The above template refers to an infinite set of H/D pairs where D is
> correctly simulated by either pure simulator H or pure function H.  This
> was done because many reviewers used the shell game ploy to endlessly
> switch which H/D pair was being referred to.
> 
> H correctly simulates 1 to ∞ steps of D with either pure function H or
> pure simulator H. In none of these cases does the correctly simulated D
> ever reach its own simulated final state and halt.

No, DIFFERENT H's simulate different number of steps of DIFFERENT 
instantations of the template D.

Until you define how to simulate "a template' by your definition, when 
the template doesn't HAVE the code of H to simulate, you are just shown 
to be LYING.

> 
> Correct Simulation Defined
>     This is provided because many reviewers had a different notion of
>     correct simulation that diverges from this notion.
> 
>     A simulator is an x86 emulator that correctly emulates 1 to N of the
>     x86 instructions of D in the order specified by the x86 instructions
>     of D. This may include M recursive emulations of H emulating itself
>     emulating D.

But your "template
  D doesn HAVE any x86 instrucitons of H.

Only all the infinte number of DIFFERENT instantiations of it.

Of course, different instantiations might have different behavior, so 
you can't just interchange them.

> 
> When we see that D correctly simulated by pure simulator H would remain
> stuck in infinite recursive simulation then we also know that less than
> an infinite number of steps is not enough steps for D correctly
> simulated by pure function H to reach its own simulated final state at
> line 06 and halt.
> 

Nope. NONE of the D's are stuck in "infinite" recursion for ANY H that 
actually aborts its simulation, since that means the H that it calls 
will also do that and terminte the apparent infinite recursion.

The problem is you can't actuala use the longer simulation to show the 
shorter simulations won't end, as the inputs are NOT the same, since, to 
do the simulation, you have created DIFFERENT instantiations.