On 8/9/24 12:15 AM, olcott wrote:

On 8/8/2024 10:54 PM, Richard Damon wrote:

On 8/8/24 11:48 PM, olcott wrote:

On 8/8/2024 10:34 PM, Richard Damon wrote:

On 8/8/24 11:03 PM, olcott wrote:

On 8/8/2024 9:52 PM, Richard Damon wrote:

On 8/8/24 9:15 AM, olcott wrote:

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.

*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*

There is no need to show any execution trace at the x86 level
every expert in the C language sees that the emulated DDD
cannot possibly reaches its "return" instruction halt state.

Every rebuttal that anyone can possibly make is necessarily
erroneous because the first paragraph is a tautology.

Nope, it is a lie based on comfusing the behavior of DDD which is
what "Halting" is.

Finally something besides
the strawman deception,
disagreeing with a tautology, or
pure ad hominem.

You must first agree with everything that I said above
before we can get to this last and final point that it
not actually directly referenced above.

Why do I need to agree to a LIE?

*Two key facts*
(a) The "return" instruction is the halt state of DDD.
(b) DDD correctly emulated by any HHH never reaches this state.

WRONG, as proven.

The SIMULATION BY HHH doesn't reach there, but DDD does,

Now you have to agree with (a).

Why? since you statement was proven false, the accuracy of one of the
terms doesn't matter.

I guess you don't understand how logic works, you have already shown
that there is a lie in your proof, and therefore it is wrong.

you changed the subject and found no lie.

Nope, since HHH is being asked about HALTING, and the definition of
Halting is about the behavior of the PROGRAM, which in this case is DDD,
and that behavior is defined as the EXECUTION of DDD, your PARTIAL
simulations are a change of subject and a LIE.

The DDD (which HHH might correctly emulated0 HALTS if the HHH returns an answer.

Which means it mapps to HALTING.

PERIOD.

FACT.

Makes your statement just wrong, and shows you to be a LIAR.

The fact you don't know this makes you IGNORANT.

The fact that you can't learn it make you an IDIOT.

Sorry, those ARE the facts and the Truth even if you can't beleive it
becasue you close your eyes to the truth because you need to beleive
your own lie.

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

On 8/9/24 9:33 AM, olcott wrote:

On 8/9/2024 6:15 AM, Richard Damon wrote:

On 8/9/24 12:15 AM, olcott wrote:

On 8/8/2024 10:54 PM, Richard Damon wrote:

On 8/8/24 11:48 PM, olcott wrote:

On 8/8/2024 10:34 PM, Richard Damon wrote:

On 8/8/24 11:03 PM, olcott wrote:

On 8/8/2024 9:52 PM, Richard Damon wrote:

On 8/8/24 9:15 AM, olcott wrote:

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.

*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*

There is no need to show any execution trace at the x86 level >>>>>>>>> every expert in the C language sees that the emulated DDD
cannot possibly reaches its "return" instruction halt state. >>>>>>>>>
Every rebuttal that anyone can possibly make is necessarily
erroneous because the first paragraph is a tautology.

Nope, it is a lie based on comfusing the behavior of DDD which >>>>>>>> is what "Halting" is.

Finally something besides
the strawman deception,
disagreeing with a tautology, or
pure ad hominem.

You must first agree with everything that I said above
before we can get to this last and final point that it
not actually directly referenced above.

Why do I need to agree to a LIE?

*Two key facts*
(a) The "return" instruction is the halt state of DDD.
(b) DDD correctly emulated by any HHH never reaches this state.

WRONG, as proven.

The SIMULATION BY HHH doesn't reach there, but DDD does,

Now you have to agree with (a).

Why? since you statement was proven false, the accuracy of one of
the terms doesn't matter.

I guess you don't understand how logic works, you have already shown
that there is a lie in your proof, and therefore it is wrong.

you changed the subject and found no lie.

Nope, since HHH is being asked about HALTING, and the definition of
Halting is about the behavior of the PROGRAM,

I will not discuss that with you until after you agree
to these two tautologies proving that you intend to be honest.

(a) The "return" instruction is the halt state of DDD.
(b) DDD correctly emulated by any HHH never reaches this state.

I have shown that your (b) is NOT a tautology, unless you stipulate that
your HHH NEVER aborts its emulation and return EVER.

You agreed with (b). No more head games about correct simulation.

No, I didn't, not unless you agree that no HHH ever aborts its emulation
and returns.

_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]

It is also a fact that the above machine code has one
halt state at machine address 00002183.

Until you agree with that statement that is true by
definition you remain stuck in a circle of trollish
head games. It won't take long before I quit looking
at anything you say.

And it WILL reach that instruction if HHH(DDD) EVER aborts its
simulation and returns.

So, you have to decide, do you want you (b) and HHH isn't a decider, or
is HHH a decider and you don't get your (b).

You can't have them both, so you "proof" is just wrong and based on the
lying shell game of changing definitions.

Sorry, the jig is up and you have been exposed.

You have been lying for years, and there is nothing you can do to refute
that, as you have admittted by not providing a shread of evidence to
support your claims, just your bluster.

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

On 8/9/24 8:52 PM, olcott wrote:

On 8/9/2024 6:46 PM, Richard Damon wrote:

On 8/9/24 9:33 AM, olcott wrote:

On 8/9/2024 6:15 AM, Richard Damon wrote:

On 8/9/24 12:15 AM, olcott wrote:

On 8/8/2024 10:54 PM, Richard Damon wrote:

On 8/8/24 11:48 PM, olcott wrote:

On 8/8/2024 10:34 PM, Richard Damon wrote:

On 8/8/24 11:03 PM, olcott wrote:

On 8/8/2024 9:52 PM, Richard Damon wrote:

On 8/8/24 9:15 AM, olcott wrote:

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.

*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*

There is no need to show any execution trace at the x86 level >>>>>>>>>>> every expert in the C language sees that the emulated DDD >>>>>>>>>>> cannot possibly reaches its "return" instruction halt state. >>>>>>>>>>>
Every rebuttal that anyone can possibly make is necessarily >>>>>>>>>>> erroneous because the first paragraph is a tautology.

Nope, it is a lie based on comfusing the behavior of DDD which >>>>>>>>>> is what "Halting" is.

Finally something besides
the strawman deception,
disagreeing with a tautology, or
pure ad hominem.

You must first agree with everything that I said above
before we can get to this last and final point that it
not actually directly referenced above.

Why do I need to agree to a LIE?

*Two key facts*
(a) The "return" instruction is the halt state of DDD.
(b) DDD correctly emulated by any HHH never reaches this state. >>>>>>>>>

WRONG, as proven.

The SIMULATION BY HHH doesn't reach there, but DDD does,

Now you have to agree with (a).

Why? since you statement was proven false, the accuracy of one of
the terms doesn't matter.

I guess you don't understand how logic works, you have already
shown that there is a lie in your proof, and therefore it is wrong. >>>>>

you changed the subject and found no lie.

Nope, since HHH is being asked about HALTING, and the definition of
Halting is about the behavior of the PROGRAM,

I will not discuss that with you until after you agree
to these two tautologies proving that you intend to be honest.

(a) The "return" instruction is the halt state of DDD.
(b) DDD correctly emulated by any HHH never reaches this state.

I have shown that your (b) is NOT a tautology, unless you stipulate
that your HHH NEVER aborts its emulation and return EVER.

One thing good about you being stuck in rebuttal mode
it that this keeps making my words get clearer and clearer.

No, you are stuck in LYING MODE.

When we look at every HHH that can possibly exist then
we see that DDD correctly emulated by each one of these
cannot possibly reach its "return" instruction halt state.

But ONLY ONE of those actuallu "correctly emulates" the input, and that
one isn't a decider.

You just confuse the fact that a PARTIAL emulation not reaching a final
state doesn't show that this input doesn't reach a final state later

And, you seem to not understand that the code of HHH is part of the code
of the PROGRAM DDD that must be given to HHH to decide, and thus every
one of your infinite set have a DIFFERENT input from all the others, and
thus you can't use one emulation to tell you what the other emulations
will do, in particular, the VERY DIFFERENT HHH that never aborts,
creates a radically different input then the ones that do abort and return.

If you want to try to claim the input is only the bytes of the C
function DDD, then you are just demonstrating that you don't know what a program is, and NO HHH can emulate that input more than 4 instructions,
so you claim is just a LIE>

Now you are trying to get away with claiming that there
are some HHH that do not belong to the set of every HHH
that can possibly exist.

Nope, where did I say that? That seems to be just another of your
impossible so substantiate claims that proves you to be a liar.

I am just pointing out that partial emulation do not show that the
complete behavior (which is what halting by definitiion looks at) does
not later hit a final state, and in fact, we can PROVE for all your HHH
that do abort and return that the DDD built on them DOES halt, and thus
all of them are incorrect to say their input is non-halting.

Sorry, you just don't have anything to stand on but your bluster and double-talk.

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

On 8/9/24 9:52 PM, olcott wrote:

On 8/9/2024 8:46 PM, Richard Damon wrote:

On 8/9/24 9:25 PM, olcott wrote:

On 8/9/2024 8:05 PM, Richard Damon wrote:

On 8/9/24 8:52 PM, olcott wrote:

When we look at every HHH that can possibly exist then
we see that DDD correctly emulated by each one of these
cannot possibly reach its "return" instruction halt state.

But ONLY ONE of those actuallu "correctly emulates" the input, and
that one isn't a decider.

In other words you are trying to keep getting away
with the bald-faced lie that when HHH correctly
emulates N instructions of DDD (where N > 0) that
it did not correctly emulate any instructions of DDD.

*Give it up you lost you are stuck in repeat mode*
*Give it up you lost you are stuck in repeat mode*
*Give it up you lost you are stuck in repeat mode*

So, I guess you don't understand English.

Where did I say that simulating N instructions correctly is not
simulating ANY instructions correctly.

*Shown above*
"But ONLY ONE of those actuallu "correctly emulates" the input..."

Right, becuase to correctly emulate, you need to correct emulate EVERY instruction, not just some of them.

Does not getting a test correct mean that you got the wrong answer to
EVERY question, or just not enough of the to be "good enough".

Sorry, you sre judt proving you don't understand the basics of English.

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

On 8/9/24 9:25 PM, olcott wrote:

On 8/9/2024 8:05 PM, Richard Damon wrote:

On 8/9/24 8:52 PM, olcott wrote:

On 8/9/2024 6:46 PM, Richard Damon wrote:

On 8/9/24 9:33 AM, olcott wrote:

On 8/9/2024 6:15 AM, Richard Damon wrote:

On 8/9/24 12:15 AM, olcott wrote:

On 8/8/2024 10:54 PM, Richard Damon wrote:

On 8/8/24 11:48 PM, olcott wrote:

On 8/8/2024 10:34 PM, Richard Damon wrote:

On 8/8/24 11:03 PM, olcott wrote:

On 8/8/2024 9:52 PM, Richard Damon wrote:

On 8/8/24 9:15 AM, olcott wrote:

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.

*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*
*There are no double-talk weasel words around this*

There is no need to show any execution trace at the x86 level >>>>>>>>>>>>> every expert in the C language sees that the emulated DDD >>>>>>>>>>>>> cannot possibly reaches its "return" instruction halt state. >>>>>>>>>>>>>
Every rebuttal that anyone can possibly make is necessarily >>>>>>>>>>>>> erroneous because the first paragraph is a tautology. >>>>>>>>>>>>>

Nope, it is a lie based on comfusing the behavior of DDD >>>>>>>>>>>> which is what "Halting" is.

Finally something besides
the strawman deception,
disagreeing with a tautology, or
pure ad hominem.

You must first agree with everything that I said above
before we can get to this last and final point that it
not actually directly referenced above.

Why do I need to agree to a LIE?

*Two key facts*
(a) The "return" instruction is the halt state of DDD.
(b) DDD correctly emulated by any HHH never reaches this state. >>>>>>>>>>>

WRONG, as proven.

The SIMULATION BY HHH doesn't reach there, but DDD does,

Now you have to agree with (a).

Why? since you statement was proven false, the accuracy of one >>>>>>>> of the terms doesn't matter.

I guess you don't understand how logic works, you have already >>>>>>>> shown that there is a lie in your proof, and therefore it is wrong. >>>>>>>

you changed the subject and found no lie.

Nope, since HHH is being asked about HALTING, and the definition
of Halting is about the behavior of the PROGRAM,

I will not discuss that with you until after you agree
to these two tautologies proving that you intend to be honest.

(a) The "return" instruction is the halt state of DDD.
(b) DDD correctly emulated by any HHH never reaches this state.

I have shown that your (b) is NOT a tautology, unless you stipulate
that your HHH NEVER aborts its emulation and return EVER.

One thing good about you being stuck in rebuttal mode
it that this keeps making my words get clearer and clearer.

No, you are stuck in LYING MODE.

When we look at every HHH that can possibly exist then
we see that DDD correctly emulated by each one of these
cannot possibly reach its "return" instruction halt state.

But ONLY ONE of those actuallu "correctly emulates" the input, and
that one isn't a decider.

In other words you are trying to keep getting away
with the bald-faced lie that when HHH correctly
emulates N instructions of DDD (where N > 0) that
it did not correctly emulate any instructions of DDD.

*Give it up you lost you are stuck in repeat mode*
*Give it up you lost you are stuck in repeat mode*
*Give it up you lost you are stuck in repeat mode*

So, I guess you don't understand English.

Where did I say that simulating N instructions correctly is not
simulating ANY instructions correctly.

It is simulaing Not-All instructions correctly, but it is required to
simulate ALL instructions correctly.

I guess this is just another of your uncounted LIES based on made up
facts that you just can't ever find proof of.

YOU are the one stuck in repeat mode.I respond to your message, you
don't actually address mine, (because apparently you have nothing to say
about it, because you haven't found a suitable lie to handle it) so you
just repeat your same DISPROVEN claim.

Sorry, you are just proving your ignorance.

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

On 8/9/24 10:24 PM, olcott wrote:

On 8/9/2024 8:54 PM, Richard Damon wrote:

On 8/9/24 9:52 PM, olcott wrote:

On 8/9/2024 8:46 PM, Richard Damon wrote:

On 8/9/24 9:25 PM, olcott wrote:

On 8/9/2024 8:05 PM, Richard Damon wrote:

On 8/9/24 8:52 PM, olcott wrote:

When we look at every HHH that can possibly exist then
we see that DDD correctly emulated by each one of these
cannot possibly reach its "return" instruction halt state.

But ONLY ONE of those actuallu "correctly emulates" the input, and >>>>>> that one isn't a decider.

In other words you are trying to keep getting away
with the bald-faced lie that when HHH correctly
emulates N instructions of DDD (where N > 0) that
it did not correctly emulate any instructions of DDD.

*Give it up you lost you are stuck in repeat mode*
*Give it up you lost you are stuck in repeat mode*
*Give it up you lost you are stuck in repeat mode*

So, I guess you don't understand English.

Where did I say that simulating N instructions correctly is not
simulating ANY instructions correctly.

*Shown above*
"But ONLY ONE of those actuallu "correctly emulates" the input..."

Right, becuase to correctly emulate, you need to correct emulate EVERY
instruction, not just some of them.

So you defining whole notion simulating termination analyzers
as incorrect even though professor Sipser has agreed that the
simulation need not be complete.

No, they just need to do the job right.

But it needs to prove that the CORRECT SIMULATION, which would be
complete, doesn't ever reach a final state. That COULD be done by
replacing the decider with a non-aborting version, but you have to do it
in a way that doesn't change the input, which means in your case, you
can't change the copy of HHH that DDD calls.

Of course, with a proper setup, where DDD has its own copy of the
decider, that wouldn't be a problem.

Since, giving THIS DDD, which calls THIS HHH, that tries to use the rule
to abort, to a actual correct simulation, we see DDD call HHH(DDD) which
WILL abort it simulation and return to DDD which then reaches its final
state, so the application of the rule by HHH could not have been based
on a correct determination that the correct simulation of this input is non-halting.

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

You lost, you are stuck in repeat mode. You have no
rebuttals that have not been proven false.

Nope, YOU have lost as you can't actually deal with ANY of the points I
bring up, but just repeat your LIES that have been previously rebutted
and not countered.

You just are too dumb to realize how stupid you are. The most stupid
type of stupid.

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

On 8/9/24 10:43 PM, olcott wrote:

On 8/9/2024 9:35 PM, Richard Damon wrote:

On 8/9/24 10:24 PM, olcott wrote:

On 8/9/2024 8:54 PM, Richard Damon wrote:

On 8/9/24 9:52 PM, olcott wrote:

On 8/9/2024 8:46 PM, Richard Damon wrote:

On 8/9/24 9:25 PM, olcott wrote:

On 8/9/2024 8:05 PM, Richard Damon wrote:

On 8/9/24 8:52 PM, olcott wrote:

When we look at every HHH that can possibly exist then
we see that DDD correctly emulated by each one of these
cannot possibly reach its "return" instruction halt state.

But ONLY ONE of those actuallu "correctly emulates" the input, >>>>>>>> and that one isn't a decider.

In other words you are trying to keep getting away
with the bald-faced lie that when HHH correctly
emulates N instructions of DDD (where N > 0) that
it did not correctly emulate any instructions of DDD.

*Give it up you lost you are stuck in repeat mode*
*Give it up you lost you are stuck in repeat mode*
*Give it up you lost you are stuck in repeat mode*

So, I guess you don't understand English.

Where did I say that simulating N instructions correctly is not
simulating ANY instructions correctly.

*Shown above*
"But ONLY ONE of those actuallu "correctly emulates" the input..."

Right, becuase to correctly emulate, you need to correct emulate
EVERY instruction, not just some of them.

So you defining whole notion simulating termination analyzers
as incorrect even though professor Sipser has agreed that the
simulation need not be complete.

No, they just need to do the job right.

But it needs to prove that the CORRECT SIMULATION, which would be
complete, doesn't ever reach a final state. T

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

You already know that a complete simulation of DDD
by a pure x86 emulator cannot possibly reach its
"return" instruction halt state.

Of course it can. as long as it isn't HHH, and the HHH that DDD was
paired with gives an answer.

Your problem is thinking the only simulator allowed is HHH.

What makes an algorithm necessarily much more ignorant
than you?

YOU.

It only needs to correctly predict the behavior of
the complete simulation. Just like you and I, it
does not have to do this complete simulation to make
this correct prediction.

Right, and if HHH aborts and returns, then the COMPLETE simulation of
the DDD that calls that HHH will see it reaching the final state.

You just don't know what a program is, so you forget that the HHH that
DDD calls is part of it, or you are just lying that the input CAN be
emulated for more than 4 instruction by a pure function.

Remember, a pure function can not use ANY external values as data other
than the input given, not even its own code.

IF you try to define that the contents of that address are "HHH", you
need to define WHAT THAT ACTUALLY IS, and thus you only have that one
HHH in every case, not your infinite set.

You just don't understand how that is a requirement, because
requirements don't seem to make sense to you since they keep you from
your lies.

Sorry, you are just too stupid to see how stupid you are, and that is
the worse type of stupid there is.

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

On 2024-08-10 02:24:11 +0000, olcott said:

On 8/9/2024 8:54 PM, Richard Damon wrote:

On 8/9/24 9:52 PM, olcott wrote:

On 8/9/2024 8:46 PM, Richard Damon wrote:

On 8/9/24 9:25 PM, olcott wrote:

On 8/9/2024 8:05 PM, Richard Damon wrote:

On 8/9/24 8:52 PM, olcott wrote:

When we look at every HHH that can possibly exist then
we see that DDD correctly emulated by each one of these
cannot possibly reach its "return" instruction halt state.

But ONLY ONE of those actuallu "correctly emulates" the input, and that >>>>>> one isn't a decider.

In other words you are trying to keep getting away
with the bald-faced lie that when HHH correctly
emulates N instructions of DDD (where N > 0) that
it did not correctly emulate any instructions of DDD.

*Give it up you lost you are stuck in repeat mode*
*Give it up you lost you are stuck in repeat mode*
*Give it up you lost you are stuck in repeat mode*

So, I guess you don't understand English.

Where did I say that simulating N instructions correctly is not
simulating ANY instructions correctly.

*Shown above*
"But ONLY ONE of those actuallu "correctly emulates" the input..."

Right, becuase to correctly emulate, you need to correct emulate EVERY
instruction, not just some of them.

So you defining whole notion simulating termination analyzers
as incorrect even though professor Sipser has agreed that the
simulation need not be complete.

The simulation needn't be complete if you call it "partial simulation".

--
Mikko

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

On 8/9/24 11:15 PM, olcott wrote:

On 8/9/2024 9:56 PM, Richard Damon wrote:

On 8/9/24 10:43 PM, olcott wrote:

On 8/9/2024 9:35 PM, Richard Damon wrote:

On 8/9/24 10:24 PM, olcott wrote:

On 8/9/2024 8:54 PM, Richard Damon wrote:

On 8/9/24 9:52 PM, olcott wrote:

On 8/9/2024 8:46 PM, Richard Damon wrote:

On 8/9/24 9:25 PM, olcott wrote:

On 8/9/2024 8:05 PM, Richard Damon wrote:

On 8/9/24 8:52 PM, olcott wrote:

When we look at every HHH that can possibly exist then
we see that DDD correctly emulated by each one of these
cannot possibly reach its "return" instruction halt state. >>>>>>>>>>

But ONLY ONE of those actuallu "correctly emulates" the input, >>>>>>>>>> and that one isn't a decider.

In other words you are trying to keep getting away
with the bald-faced lie that when HHH correctly
emulates N instructions of DDD (where N > 0) that
it did not correctly emulate any instructions of DDD.

*Give it up you lost you are stuck in repeat mode*
*Give it up you lost you are stuck in repeat mode*
*Give it up you lost you are stuck in repeat mode*

So, I guess you don't understand English.

Where did I say that simulating N instructions correctly is not >>>>>>>> simulating ANY instructions correctly.

*Shown above*
"But ONLY ONE of those actuallu "correctly emulates" the input..." >>>>>>>

Right, becuase to correctly emulate, you need to correct emulate
EVERY instruction, not just some of them.

So you defining whole notion simulating termination analyzers
as incorrect even though professor Sipser has agreed that the
simulation need not be complete.

No, they just need to do the job right.

But it needs to prove that the CORRECT SIMULATION, which would be
complete, doesn't ever reach a final state. T

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

You already know that a complete simulation of DDD
by a pure x86 emulator cannot possibly reach its
"return" instruction halt state.

Of course it can. as long as it isn't HHH, and the HHH that DDD was
paired with gives an answer.

Your problem is thinking the only simulator allowed is HHH.

When HHH reports that its input cannot possibly reach
the "return" instruction halt state of this input it
is correct. HHH only computes the mapping from its input
to the behavior that this input specifies.

No, the "input" is the full program, and even you have admitted that
when that program is run directly it halts.

Thus, the "mapping" it NEEDS to try to compute says that input Halts.

The fact that HHH aborts its partial emulation before it gets there
doesn't mean that the program doesn't get there.

Thus, HHH reports incorrectly, because its programmer doesn't understand
that the code for DDD actually included the code for HHH, and thus HHH
must treat that call like a call to itself, and thus know that if it
will return (which it will if it is a decider), then the code it is
simulating will return from the call.

All of your every attempt to rebut this were anchored
in the strawman deception. I am beginning to have no
doubts that you are a deceiver. For your soul's sake
I hope this is an ADD issue and not willful deception.

No, you are just showing you don't understand the difference between a
partial emulation of a program and the full behavior of it. OR maybe
what the original question was asking.

This seems to be rooted in you inability to distinguish fantasy from
reality.

Sorry, you are just proving to the world how stupid you are, and that
you can't see how stupid you are, which is the worse type of stupid.

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