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

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["

"Colorless green ideas sleep furiously" https://en.wikipedia.org/wiki/Colorless_green_ideas_sleep_furiously
Has lots of meaning, that does not totally fit together coherently.

I defined an infinite set of HHH x86 emulators.

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

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

No, since all the emulator that only emulated a finite number of steps
did not complete the job, and thus did NOT determine the actual mapping
of that input, which is determined by RUNNING that DDD, or COMPLETELY
emulating it, which will see the DDD call HHH(DDD) which will after
emulationg that finite number of instructions return to DDD which will halt.

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

Right, but any number emulated that is less than the number of
instructions that particular input needs to have run to reach a final
state is just INCORRECT, since all the HHH that abort DO create an input
that will halt in a finite number of steps, just at a value of N bigger
than the number of steps that HHH emulated.

You just don't understand the question you claim to be answering.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/9/24 1:02 PM, olcott wrote:

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

Op 09.aug.2024 om 17:04 schreef olcott:

void Infinite_Loop()

{
   HERE: goto HERE;
}

The correct simulation of the above never halts.

void DDD()
{
  HHH(DDD);
  return;
}

A correct simulation of N instructions of DDD <is>
A correct simulation of N instructions of DDD.
You are trying to get away with denying a truism.

But not a correct simulation of ALL the instruction of DDD, so doesn't
indicate if it halts.

I guess you think if you drive one mile on a highway, and then get off
because you think the road will never stop, that proves that the road
will never stop.

Sorry, it doesn't work that way, The only simulation that shows, by
itself, that an input to be non-halting, is a simulation that runs forever.

Remember, EVERY DDD that calls a different HHH is a different input and
has a different correct simulation, and all of the ones that use a HHH
that aborts and returns will halt themselves even though HHH's
simulation didn't reach there.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

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, and thus MUST include all of the
instructions use, including that of all the routines it calls.

Since HHH has been shown to NOT do a correct emulation, claims of what a correct emulation does are irrelevent.

Since every HHH is different, and creates a different DDD, it is just a
LIE to use the behavior of one DDD/HHH pair to justify the behavior of a differents HHH's input.

Sorry, you are just proving yourself to be too stupid to understand your
own misunderstandings, which is the worse type of stupid to be.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

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

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

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

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

Op 09.aug.2024 om 22:53 schreef olcott:

On 8/9/2024 2:35 PM, Fred. Zwarts wrote:

Op 09.aug.2024 om 18:19 schreef olcott:

void DDD()
{
   HHH(DDD);
   return;
}

Each HHH of every HHH that can possibly exist definitely
emulates zero to infinity instructions of DDD correctly.
Every expert in the C language sees that this emulated DDD
cannot possibly reaches its own "return" instruction halt state.

And you don't need to be an expert to see that this proves that all
these simulations are incorrect.

In other words you are trying to get away with the lie that
Richard has been persistently pushing:

When N > 0 instructions of DDD are correctly emulated by HHH
then no instructions of DDD have been correctly emulated.

No, that is just a lie you say about me.

Your deceptive words confuse even you?
If the only correct simulation is a compete simulation that entails
this:
When N > 0 instructions of DDD are correctly emulated by HHH
then no instructions of DDD have been correctly emulated.

Nope. You are just proving you don't understand logic.

Why do you thinl NOT-ALL means NONE?


You are just proving your utter stupidity, and that you are so stupid
you can't understand you stupidity, which is the worse type of stupid to be.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)