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
Subject: Re: Computable Functions --- finite string transformation rules
Date: Fri, 25 Apr 2025 15:07:51 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <bc2be0c83710704bcdf1454ec9832b9c6c7276d1@i2pn2.org>
References: <vsnchj$23nrb$2@dont-email.me> <vtlu0a$3vgp0$1@dont-email.me>
 <vtm04f$2a90$1@dont-email.me> <vtm9q8$aut7$1@dont-email.me>
 <vtmah8$2a90$2@dont-email.me> <vtmgen$gs48$1@dont-email.me>
 <c2ad5086dba36124c070173c3e3252967df2fab9@i2pn2.org>
 <vu8g3q$v0qa$1@dont-email.me> <vu8lse$vn9b$1@dont-email.me>
 <vu8og4$13jl5$7@dont-email.me>
 <6d9ae3ac08bbbe4407fc3612441fc2032f949a3d@i2pn2.org>
 <vub168$3clpn$2@dont-email.me>
 <7ac75991b443ba53d52960ddb1932524dea8e03f@i2pn2.org>
 <40b048f71fe2ed2a8ef11d2d587c765c8fcbc977@i2pn2.org>
 <vucrgq$148pf$1@dont-email.me> <vudkt8$1ona3$2@dont-email.me>
 <vudp39$1rhdn$1@dont-email.me> <vudrgb$20gck$1@dont-email.me>
 <vue2fb$27hl3$1@dont-email.me> <vue464$28iho$2@dont-email.me>
 <3fcc6700e2a832dbae42afd82a4e2cf3a9d85dee@i2pn2.org>
 <vueta8$31sno$1@dont-email.me> <vuettb$31h9n$1@dont-email.me>
 <vuf4gv$38ei5$1@dont-email.me> <vuftks$3tsjm$1@dont-email.me>
 <vugkee$it5g$1@dont-email.me> <vugks6$i5k4$1@dont-email.me>
 <vuglkb$it5g$3@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Fri, 25 Apr 2025 19:08:01 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="1863658"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
In-Reply-To: <vuglkb$it5g$3@dont-email.me>
Content-Language: en-US
X-Spam-Checker-Version: SpamAssassin 4.0.0
Bytes: 6353
Lines: 109

On 4/25/25 2:51 PM, olcott wrote:
> On 4/25/2025 1:39 PM, dbush wrote:
>> On 4/25/2025 2:31 PM, olcott wrote:
>>> On 4/25/2025 7:02 AM, dbush wrote:
>>>> On 4/25/2025 12:53 AM, olcott wrote:
>>>>> On 4/24/2025 10:00 PM, dbush wrote:
>>>>>> On 4/24/2025 10:50 PM, olcott wrote:
>>>>>>> On 4/24/2025 6:07 PM, Richard Damon wrote:
>>>>>>>> On 4/24/25 3:41 PM, olcott wrote:
>>>>>>>>> On 4/24/2025 2:12 PM, Fred. Zwarts wrote:
>>>>>>>>>> Op 24.apr.2025 om 19:13 schreef olcott:
>>>>>>>>>>>
>>>>>>>>>>> HHH correctly determines through mathematical induction that
>>>>>>>>>>> DD emulated by HHH (according to the finite string 
>>>>>>>>>>> transformations
>>>>>>>>>>> specified by the x86 language) cannot possibly reach its final
>>>>>>>>>>> halt state in an infinite number of steps.
>>>>>>>>>
>>>>>>>>>> No, HHH has a bug which makes that it fails to see that there 
>>>>>>>>>> is only a finite recursion, 
>>>>>>>>>
>>>>>>>>> *You are technically incompetent on this point*
>>>>>>>>> When the finite string transformation rules of the
>>>>>>>>> x86 language are applied to the input to HHH(DD)
>>>>>>>>> THIS DD CANNOT POSSIBLY REACH ITS FINAL HALT STATE
>>>>>>>>> not even after an infinite number of emulated steps.
>>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>> When the defined finite string trasnsformation rules, thos of 
>>>>>>>> the x86 language, are applied to this input, completed with the 
>>>>>>>> definitions from Halt7.c as stipulated, we see that DD calls 
>>>>>>>> HHH(DD), that it will spend some time emulating DDm then it will
>>>>>>>
>>>>>>> Correctly determine that DD emulated by HHH can never possibly
>>>>>>> reach its final halt state even after an infinite number of
>>>>>>> steps are emulated.
>>>>>>
>>>>>> Category error.  The fixed code of algorithm HHH, which is part of 
>>>>>> the input as you agreed, emulates for a fixed number of steps. 
>>>>>> Therefore there is no infinite number of steps emulated by 
>>>>>> algorithm HHH.
>>>>>>
>>>>>
>>>>> You are flat out stupid about hypothetical possibilities.
>>>>> Of every possible HHH/DD pair where DD calls HHH(DD) and
>>>>> DD is emulated by HHH according to the finite string transformation
>>>>> rules of the x86 language no DD ever reaches its own final halt state.
>>>>>
>>>>
>>>> In other words, you're hypothesizing changing the input.
>>>>
>>>> Changing the input, hypothetically or otherwise, is not allowed.
>>>>
>>>>
>>>
>>> I am only saying the ALL X are Y.
>>> Only Trolls would have difficulty with this.
>>
>> No, you're saying that 
> 
> For every possible HHH/DD pair where HHH emulates 0 to ∞

But those don't exist, because HHH has been stipulated to be the ONE 
machine defined in Halt7.c

Sorry, you are not allowed to change it without giving up that 
stipulation, and if you do then you hit the problem that DD now isn't 
defined, as you don't have a single definition of the HHH that it calls.

> instructions of DD (according to the finite string
> transformation rules specified by the x86 language)
> no DD ever reaches its final halt state.

But since you have retracted you definition of Halt7.c, then either your 
definition of DD changes for every different HHH you are thinking of, 
and thus you argument breaks as it isn't trying to look at the same 
input, or the input just doesn't have behavior.

You can't do induction on a criteria that changes for each n.

Sorry, you are just proving your ignorance of what you are talking about.

> 
> When ALL X are Y then zero X are not Y, Trolls may disagree.

But if there is only 1 X, then there is only 1 Y, and X's claim that it 
is correctly emulating its input is a lie, as no induction has been done.

> 
> int DD()
> {
>    int Halt_Status = HHH(DD);
>    if (Halt_Status)
>      HERE: goto HERE;
>    return Halt_Status;
> }
> 

It is still a FACT that if HHH has been defined to do what you say, DD 
will halt. and the correect emulation of DD by a emulator that actually 
does a complete emulation will halt, and it is a fact that NONE of your 
HHH's in the full infinte set ever did that emulation.

Your arguement is basically like saying if we define M to be N+1, that M 
must be infinite, because there is no finte number N where N > M.

The problme is you can't do the induction over N to look at the changing M.

You are just showing your utter stupidity,