Re: HHH(DDD) computes the mapping from its input to HHH emulating itself emulating DDD --- anyone that says otherwise is a liar

On 11/22/24 6:56 PM, olcott wrote:

On 11/22/2024 5:03 PM, Richard Damon wrote:

On 11/22/24 5:57 PM, olcott wrote:

On 11/22/2024 2:03 PM, Richard Damon wrote:

On 11/22/24 1:44 PM, olcott wrote:

On 11/22/2024 12:37 PM, Richard Damon wrote:

On 11/22/24 1:28 PM, olcott wrote:

On 11/22/2024 12:07 PM, joes wrote:

Am Fri, 22 Nov 2024 10:36:25 -0600 schrieb olcott:

On 11/22/2024 9:16 AM, joes wrote:

Am Fri, 22 Nov 2024 08:50:33 -0600 schrieb olcott:

On 11/22/2024 6:20 AM, joes wrote:

Am Thu, 21 Nov 2024 15:19:43 -0600 schrieb olcott:

On 11/21/2024 3:11 PM, joes wrote:

Am Thu, 21 Nov 2024 09:19:03 -0600 schrieb olcott:

On 11/20/2024 10:00 PM, Richard Damon wrote:

On 11/20/24 9:57 PM, olcott wrote:

On 11/20/2024 5:51 PM, Richard Damon wrote:

On 11/20/24 5:03 PM, olcott wrote:

On 11/20/2024 3:53 AM, Mikko wrote:

On 2024-11-20 03:23:12 +0000, olcott said:

On 11/19/2024 4:12 AM, Mikko wrote:

On 2024-11-18 20:42:02 +0000, olcott said:

On 11/18/2024 3:41 AM, Mikko wrote:

The "the mapping" on the subject line is not correct. The
subject line does not specify which mapping and there is
no larger context that could specify that. Therefore it
should be "a mapping".
On 2024-11-17 18:36:17 +0000, olcott said:

>

But it gets the wrong answer for the halting problem, as DDD dpes
halt.

DDD emulated by HHH does not halt.

Whatever. DDD halts and HHH should return that.

IT IS NOT THE SAME INSTANCE OF DDD.

All instances of DDD behave the same (if it is a pure function and
the HHH called from it doesn't switch behaviour by a static
variable).

Only HHH is required to be a pure function, DDD is expressly allowed
to be any damn thing.

TMs don't have side effects, such as reading a static Root variable.

The static root variable has not one damn thing to do with the
fact that DDD emulated by HHH cannot possibly reach its own "return"
instruction.

It does. If it were always set to True, all instances of the same HHH
would abort and halt. Why else would it be there?
>

>
WE HAVE NOT BEEN TALKING ABOUT ABORT/NOT ABORT
FOR THREE FREAKING MONTHS. WAKE THE F-CK UP.
>
WE HAVE BEEN TALKING ABOUT DDD EMULATED BY HHH
REACHING ITS FINAL HALT STATE
>

>
So, does HHH abort or not abort it emulation?
>

>
Of the infinite set of every HHH that emulates N steps
of DDD no DDD ever reaches its final halt state.
>

>
So?
>
Without including HHH in the input, at least implicitly, they couldn't have done what you said, so you are admitting that the actual input DDD must include the code of HHH, or you are just a liar.
>

>
You are just trying to get away with changing the subject.
The question is: Can DDD emulated by any HHH possibly
reach its final halt state.
>

>
The question (in computation theory) CAN'T be that, is it isn't a valid question, as it isn't an objective quesiton about just DDD.
>

 In other words you are trying to get away pretending that
the fact that DDD defines a pathological relationship to
HHH can be simply ignored. How is that not stupid?
   

No, but it does mean that HHH needs to CORRECTLY handle that relationship, which is that it needs to understand that the HHH that DDD calls will do exactly what it does.
The "pathology" of the relationship doesn't change the rules for how anythibng works, just makes it that a simple emulation can't handle the problem.
You still have the problem that your DDD isn't a valid input for a semantic decider as it isn't a semantically valid input, having missing code.
You are just proving your utter stupidity, and that you believe that lies are allowed in logic. Sorry, but that is the fact, the input to a semantic decider MUST be a COMPLETE set of code, including the code of all sub-functions used.
Until you define what you "alternate" system is based on, you are stuck with those rules, and are just proving that you are a pathological liar by ignoring them,