Re: HHH maps its input to the behavior specified by it --- Which if HHH returns, will be halting.

On 8/10/24 1:37 PM, olcott wrote:

On 8/10/2024 12:23 PM, Richard Damon wrote:

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

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.
>

>
Which isn't "what the hell it does". but a correct x86 emulation by the semantic of the x86 language will ALWAYS and ONLY behave EXACTLY like that input when run as a program,

 <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
     If simulating halt decider H correctly simulates its input D
     until H correctly determines that its simulated D would never
     stop running unless aborted then
      H can abort its simulation of D and correctly report that D
     specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
 That is true in every case except when an input calls its
own simulating halt decider.

Nope. No exeptions. That is just another of your "I made it up but can't prove it but it must be true" lies.

 void DDD()
{
   HHH(DDD);
   return;
}
 *The set of HHH x86 emulators are defined such that*
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.

But every one that emulates for a finite number of steps, and then returns create a halting DDD, so you claim is just disproven.

 In the above set no DDD ever reaches its own “return”
instruction halt state thus every HHH can correctly report this.
 

Of course they do, what don't reach there is the partial emulation by the partial emulator.
This is why partial emulations are not "correct" but only partial.