Re: HHH maps its input to the behavior specified by it --- never reaches its halt state ---natural number mapping

On 8/10/2024 1:35 PM, Fred. Zwarts wrote:

Op 10.aug.2024 om 16:24 schreef olcott:

On 8/10/2024 9:00 AM, Fred. Zwarts wrote:

Op 10.aug.2024 om 15:37 schreef olcott:

On 8/10/2024 8:21 AM, Fred. Zwarts wrote:

Op 10.aug.2024 om 14:06 schreef olcott:

On 8/10/2024 6:57 AM, Richard Damon wrote:

On 8/10/24 7:30 AM, olcott wrote:

On 8/10/2024 3:29 AM, Mikko wrote:

On 2024-08-09 14:51:51 +0000, olcott said:
>

On 8/9/2024 4:03 AM, Mikko wrote:

On 2024-08-08 13:18:34 +0000, olcott said:
>

void DDD()
{
   HHH(DDD);
   return;
}
>
Each HHH of every HHH that can possibly exist definitely
*emulates zero to infinity instructions correctly* In
none of these cases does the emulated DDD ever reach
its "return" instruction halt state.

>
The ranges of "each HHH" and "every HHH" are not defined above
so that does not really mean anything.

>
Here is something that literally does not mean anything:
"0i34ine ir m0945r (*&ubYU  I*(ubn)I*054 gfdpodf["

>
Looks like encrypted text that might mean something.
>

"Colorless green ideas sleep furiously"

>
This could be encrypted text, too, or perhaps refers to some
inside knowledge or convention.
>

I defined an infinite set of HHH x86 emulators.

>
Maybe somewnete but not in the message I commented.
>

I stipulated that each member of this set emulates
zero to infinity instructions of DDD.

>
That doesn't restrict much.
>

*I can't say it this way without losing 90% of my audience*
Each element of this set is mapped to one element of the
set of non-negative integers indicating the number of
x86 instructions of DDD that it emulates.

>
It is easier to talk about mapping if is given a name.
>

*This one seems to be good*
Each element of this set corresponds to one element of
the set of positive integers indicating the number of
x86 instructions of DDD that it emulates.

>
That would mean that only a finite number (possibly zero) of
instructions is emulated. But the restriction to DDD does not
seem reasonable.
>

>
*The set of HHH x86 emulators are defined such that*

>
I thopught HHH was a deider?
>

>
Each element of this set corresponds to one element of
the set of positive integers indicating the number of
x86 instructions of DDD that it correctly emulates.

>
And only those element of the set that either reach the final state, or simulate forever are "correct" emulators of the whole program, suitable to show halting.
>

>
void DDD()
{
   HHH(DDD);
   return;
}
>
In other words even though it is dead obvious to
us that a complete simulation of DDD simulated by HHH

>
is impossible, because HHH is programmed to abort and, therefore, it is unable to do a complete simulation.

>
A complete simulation of DDD by a pure x86 emulator
named HHH cannot possibly reach its own "return"
instruction halt state.

>
Indeed, HHH fails to reach its own halt state. HHH cannot possibly simulate itself up to its halt state.
Which proves that the simulation is incomplete and, therefore, incorrect.
>

>
That an emulation of an input is necessary correct no matter
what-the-Hell it does as long as it conforms to the semantics
of the x86 language is either over your head or you persistently
lie about it.
>

 No evidence for these claims. We know that a simulation of a halting program is correct only when it reaches the halt state,

void Infinite_Recursion()
{
   Infinite_Recursion();
}
void Infinite_Loop()
{
   HERE: goto HERE;
}
You seem to be an ignoramus. Ordinary ignorance can be corrected.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer