On 8/2/24 4:57 PM, olcott wrote:

Who here is too stupid to know that DDD correctly simulated
by HHH cannot possibly reach its own return instruction?

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

Right, but the only HHH that correctly simulates is the one that never
aborts, and thus fails to be a decider, and that isn't the HHH that you actually have shown the code for, or claim to be right.


Your HHH that does abort, doesn't do a correct simulation and get the
wrong answer.


Note, the simulation of the call to HHH MUST be simulated by going into
HHH and seeing what it does, something NONE of your traces generated by
HHH have been shown to do.

And, an aborted simulation is NEVER correct, unless the point that it
aborted was a point in the code that the code actually stops running at,
which will be the finial return from DDD. The ACTUAL correct simulation
of ANY DDD that calls an HHH that answers will also reach that final
state, thus no HHH is correct to say the DDD that calls it is non-halting.

The HHH that aborts is simulation of the DDD above that calls itself is
just incorrect, as it has just proved that it isn't the HHH that we
agreed makes a non-halting input.

You are just proving your utter stupidity and that you are just an
ignorant pathological liar that intentionally conflates the two versions
of HHH.

Sorry, your reputation is just DEAD because YOU have killed by by
telling all your lies, proving that you logic is worthless and that you
are just ignorant.

That is just the facts.

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

On 8/2/24 6:06 PM, olcott wrote:

On 8/2/2024 4:41 PM, Richard Damon wrote:

On 8/2/24 4:57 PM, olcott wrote:

Who here is too stupid to know that DDD correctly simulated
by HHH cannot possibly reach its own return instruction?

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

Right, but the only HHH that correctly simulates is the one that never
aborts, and thus fails to be a decider, and that isn't the HHH that
you actually have shown the code for, or claim to be right.

That is probably the least stupid answer here recently.
Mikko, Joes, and Fred would probably not do as well. Let's
see if the others can catch up to at least this much.

Mike is usually pretty good at his analysis until recently.
He may not understand this key aspect as well as you do.

So you accept that the only DDD that is non-halting is the DDD that
calls the HHH that does a fully correct emulation of its input, and thus doesn't abort it?

That means you admit that all the other HHHs, when given the DDD that
calls them, are just wrong.

OK. you admit that you proof doesn't works.

SO LONG, and thanks for all the fish.

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

On 8/2/24 6:24 PM, olcott wrote:

On 8/2/2024 5:12 PM, Richard Damon wrote:

On 8/2/24 6:06 PM, olcott wrote:

On 8/2/2024 4:41 PM, Richard Damon wrote:

On 8/2/24 4:57 PM, olcott wrote:

Who here is too stupid to know that DDD correctly simulated
by HHH cannot possibly reach its own return instruction?

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

Right, but the only HHH that correctly simulates is the one that
never aborts, and thus fails to be a decider, and that isn't the HHH
that you actually have shown the code for, or claim to be right.

That is probably the least stupid answer here recently.
Mikko, Joes, and Fred would probably not do as well. Let's
see if the others can catch up to at least this much.

Mike is usually pretty good at his analysis until recently.
He may not understand this key aspect as well as you do.

So you accept that the only DDD that is non-halting is the DDD that
calls the HHH that does a fully correct emulation of its input, and
thus doesn't abort it?

I never said that. The fact the we agree on one key point may
be helpful to get others to agree to this one key point.

You did not even get this one key point exactly correctly in
that you answered a different question than the exact question
that I actually asked. You did seem to get it better than Joes,
Fred or Mikko.

Then you can't use that point, as obviously we disagree on a key
definition in it.

Fundamentally, your problem is that you don't understand that words have specific meanings, that can depend on the context, and you don't get to
change them.

Since it is clear that you don't understand what most of the key terms
mean, your statments just become falsehoods.

For instance, you don't understand that as an input, DDD *MUST* contain
the code of HHH as part of it, and thus, which HHH is there matters.

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

On 8/2/2024 5:41 PM, Richard Damon wrote:

On 8/2/24 6:24 PM, olcott wrote:

On 8/2/2024 5:12 PM, Richard Damon wrote:

On 8/2/24 6:06 PM, olcott wrote:

On 8/2/2024 4:41 PM, Richard Damon wrote:

On 8/2/24 4:57 PM, olcott wrote:

Who here is too stupid to know that DDD correctly simulated
by HHH cannot possibly reach its own return instruction?

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

Right, but the only HHH that correctly simulates is the one that
never aborts, and thus fails to be a decider, and that isn't the
HHH that you actually have shown the code for, or claim to be right. >>>>>

That is probably the least stupid answer here recently.
Mikko, Joes, and Fred would probably not do as well. Let's
see if the others can catch up to at least this much.

Mike is usually pretty good at his analysis until recently.
He may not understand this key aspect as well as you do.

So you accept that the only DDD that is non-halting is the DDD that
calls the HHH that does a fully correct emulation of its input, and
thus doesn't abort it?

I never said that. The fact the we agree on one key point may
be helpful to get others to agree to this one key point.

You did not even get this one key point exactly correctly in
that you answered a different question than the exact question
that I actually asked. You did seem to get it better than Joes,
Fred or Mikko.

Then you can't use that point, as obviously we disagree on a key
definition in it.

We agree that if HHH never aborts then DDD never halts.

You did not even get this one key point exactly correctly in
that you answered a different question than the exact question
that I actually asked.

Who here is too stupid to know that DDD correctly simulated by HHH
cannot possibly reach its own return instruction?

Who here is too stupid to know that DDD correctly simulated by HHH
cannot possibly reach its own return instruction?

Who here is too stupid to know that DDD correctly simulated by HHH
cannot possibly reach its own return instruction?



--
Copyright 2024 Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

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

On 8/2/24 6:51 PM, olcott wrote:

On 8/2/2024 5:41 PM, Richard Damon wrote:

On 8/2/24 6:24 PM, olcott wrote:

On 8/2/2024 5:12 PM, Richard Damon wrote:

On 8/2/24 6:06 PM, olcott wrote:

On 8/2/2024 4:41 PM, Richard Damon wrote:

On 8/2/24 4:57 PM, olcott wrote:

Who here is too stupid to know that DDD correctly simulated
by HHH cannot possibly reach its own return instruction?

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

Right, but the only HHH that correctly simulates is the one that
never aborts, and thus fails to be a decider, and that isn't the
HHH that you actually have shown the code for, or claim to be right. >>>>>>

That is probably the least stupid answer here recently.
Mikko, Joes, and Fred would probably not do as well. Let's
see if the others can catch up to at least this much.

Mike is usually pretty good at his analysis until recently.
He may not understand this key aspect as well as you do.

So you accept that the only DDD that is non-halting is the DDD that
calls the HHH that does a fully correct emulation of its input, and
thus doesn't abort it?

I never said that. The fact the we agree on one key point may
be helpful to get others to agree to this one key point.

You did not even get this one key point exactly correctly in
that you answered a different question than the exact question
that I actually asked. You did seem to get it better than Joes,
Fred or Mikko.

Then you can't use that point, as obviously we disagree on a key
definition in it.

We agree that if HHH never aborts then DDD never halts.

No, if the one and only HHH in the problem is programmed not to abort,
then DDD never halts.

You don't seem to understand that HHH is that (in a given example) HHH
is a fixed piece of code with a defined algorithm and behavior.

You did not even get this one key point exactly correctly in
that you answered a different question than the exact question
that I actually asked.

because I like to answer the question that you seem to be really meaning
to be asking.

I am not a robot slaved to his programming. I am not so sure about you.

Who here is too stupid to know that DDD correctly simulated by HHH
cannot possibly reach its own return instruction?

YOU ARE TOO STUPID TO KNOW WHAT YOU ARE TALKING ABOUT.

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

On 8/2/2024 6:23 PM, Richard Damon wrote:

On 8/2/24 6:51 PM, olcott wrote:

On 8/2/2024 5:41 PM, Richard Damon wrote:

On 8/2/24 6:24 PM, olcott wrote:

On 8/2/2024 5:12 PM, Richard Damon wrote:

On 8/2/24 6:06 PM, olcott wrote:

On 8/2/2024 4:41 PM, Richard Damon wrote:

On 8/2/24 4:57 PM, olcott wrote:

Who here is too stupid to know that DDD correctly simulated
by HHH cannot possibly reach its own return instruction?

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

Right, but the only HHH that correctly simulates is the one that >>>>>>> never aborts, and thus fails to be a decider, and that isn't the >>>>>>> HHH that you actually have shown the code for, or claim to be right. >>>>>>>

That is probably the least stupid answer here recently.
Mikko, Joes, and Fred would probably not do as well. Let's
see if the others can catch up to at least this much.

Mike is usually pretty good at his analysis until recently.
He may not understand this key aspect as well as you do.

So you accept that the only DDD that is non-halting is the DDD that
calls the HHH that does a fully correct emulation of its input, and
thus doesn't abort it?

I never said that. The fact the we agree on one key point may
be helpful to get others to agree to this one key point.

You did not even get this one key point exactly correctly in
that you answered a different question than the exact question
that I actually asked. You did seem to get it better than Joes,
Fred or Mikko.

Then you can't use that point, as obviously we disagree on a key
definition in it.

We agree that if HHH never aborts then DDD never halts.

No, if the one and only HHH in the problem is programmed not to abort,
then DDD never halts.

You don't seem to understand that HHH is that (in a given example) HHH
is a fixed piece of code with a defined algorithm and behavior.

You did not even get this one key point exactly correctly in
that you answered a different question than the exact question
that I actually asked.

because I like to answer the question that you seem to be really meaning
to be asking.

In other words you are too stupid, as I expected.


--
Copyright 2024 Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

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

Op 02.aug.2024 om 22:57 schreef olcott:

Who here is too stupid to know that DDD correctly simulated
by HHH cannot possibly reach its own return instruction?

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

Which proves that the simulation is incorrect.
You are hopeless to repeat the same error without any evidence again and
again.
A correct simulation should of a halting program must reach the
simulation of its return instruction.
HHH cannot possibly simulate itself correctly.
Even repeating thousand times the word 'correct', it does not make the simulation correct.
No matter how much olcott wants it to be correct, or how many times
olcott repeats that it is correct, it does not change the fact that such
a simulation is incorrect, because it is unable to reach the end of a
halting program.
Olcott's own claim that the simulated HHH does not reach its end
confirms it. The trace he has shown also proves that HHH cannot reach
the end of its own simulation. So, his own claims prove that it is true
that HHH cannot possibly simulate itself up to the end, which makes the simulation incomplete and, therefore, incorrect.
Dreams are no substitute for logic proofs.

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

On 2024-08-02 20:57:26 +0000, olcott said:

Who here is too stupid to know that DDD correctly simulated
by HHH cannot possibly reach its own return instruction?

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

Everyone here understands that that depends on whther HHH returns.

--
Mikko

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

Op 03.aug.2024 om 15:50 schreef olcott:

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

Op 02.aug.2024 om 22:57 schreef olcott:

Who here is too stupid to know that DDD correctly simulated
by HHH cannot possibly reach its own return instruction?

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

Which proves that the simulation is incorrect.

When are you going to understand that you are not allowed
to disagree with the semantics of the x86 language?

I do not disagree.
When are you going to understand that it is a deviation of the semantics
of the x86 language to skip instructions of a halting program, only
because you are dreaming of a non-halting HHH?
DDD is a misleading and unneeded complication. It is easy to eliminate DDD:

int main() {
return HHH(main);
}

This has the same problem. This proves that the problem is not in DDD,
but in HHH, which halts when it aborts the simulation, but it decides
that the simulation of itself does not halt.
It shows that HHH cannot possibly simulate itself correctly.

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

Op 03.aug.2024 om 15:58 schreef olcott:

On 8/3/2024 3:19 AM, Mikko wrote:

On 2024-08-02 20:57:26 +0000, olcott said:

Who here is too stupid to know that DDD correctly simulated
by HHH cannot possibly reach its own return instruction?

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

Everyone here understands that that depends on whther HHH returns.

Fred's understanding is worse than that.
Some have deeper understanding than that.

*Ben has the best understanding of all*

On 10/14/2022 7:44 PM, Ben Bacarisse wrote:

I don't think that is the shell game.  PO really /has/ an H
(it's trivial to do for this one case) that correctly determines
that P(P) *would* never stop running *unless* aborted.

...

But H determines (correctly) that D would not halt if it
were not halted.  That much is a truism.

we are talking about H that aborts and halts.
Dreaming of a HHH that does not halt if it were no halted may be
relaxing, but it is completely irrelevant.
Olcott still does not understand that such dreams have no effect on the
coded HHH that is programmed to abort and halt.
When it halts it halts, but that is already too difficult for olcott.
He keeps dreaming of HHH that does not halt.

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

Op 03.aug.2024 om 16:37 schreef olcott:

On 8/3/2024 9:08 AM, Fred. Zwarts wrote:

Op 03.aug.2024 om 15:58 schreef olcott:

On 8/3/2024 3:19 AM, Mikko wrote:

On 2024-08-02 20:57:26 +0000, olcott said:

Who here is too stupid to know that DDD correctly simulated
by HHH cannot possibly reach its own return instruction?

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

Everyone here understands that that depends on whther HHH returns.

Fred's understanding is worse than that.
Some have deeper understanding than that.

*Ben has the best understanding of all*

On 10/14/2022 7:44 PM, Ben Bacarisse wrote:

I don't think that is the shell game.  PO really /has/ an H
(it's trivial to do for this one case) that correctly determines
that P(P) *would* never stop running *unless* aborted.

...

But H determines (correctly) that D would not halt if it
were not halted.  That much is a truism.

we are talking about H that aborts and halts.
Dreaming of a HHH that does not halt if it were no halted may be
relaxing, but it is completely irrelevant.
Olcott still does not understand that such dreams have no effect on
the coded HHH that is programmed to abort and halt.
When it halts it halts, but that is already too difficult for olcott.
He keeps dreaming of HHH that does not halt.

*Ben's understanding is correct yours is incorrect*
Ben's understanding refers to applying this criteria
to the following code where H(D,D) halts.

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

You can repeat this irrelevant quote many more times, but it is
irrelevant, because it speaks about a correct simulation and HHH's
simulation of itself is incorrect.
The simulation of a halting program halts.
That is a tautology in your terms. Disagreeing with it is denying a truism.
HHH halts, because it is coded to abort and halt.

int D(int (*x)())
{
  int Halt_Status = H(x, x);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
}

int main()
{
  H(D,D);
}

In the above code D correctly simulated by H cannot possibly

Still no evidence for your claim.
You may wish very, very much that it is correct. You can repeat many,
many times the word 'correctly'. But it does not make it correct.

reach its own second instruction, thus cannot possibly reach
its own halt state of "return".

Proving that the simulation is incorrect.
H is programmed to abort and halt. When H would correctly simulate
itself, the simulated H would return and D would reach the line
following the call to H.
That it does not do that, proves that the simulation is incorrect.
H cannot possibly simulate itself correctly, because it aborts the
simulation too soon. It does not even reach the part of D that
contradict H's prediction.
Because H does a premature abort, you keep dreaming of a H that does not
abort and does not terminate.
Dreams are no substitute for facts.

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

Op 03.aug.2024 om 16:26 schreef olcott:

On 8/3/2024 9:04 AM, Fred. Zwarts wrote:

Op 03.aug.2024 om 15:50 schreef olcott:

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

Op 02.aug.2024 om 22:57 schreef olcott:

Who here is too stupid to know that DDD correctly simulated
by HHH cannot possibly reach its own return instruction?

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

Which proves that the simulation is incorrect.

When are you going to understand that you are not allowed
to disagree with the semantics of the x86 language?

I do not disagree.
When are you going to understand that it is a deviation of the
semantics of the x86 language to skip instructions of a halting program,

HHH(DDD) simulates DDD that calls HHH(DDD) to repeat the process.

If it does this an infinite number of times the simulated DDD
never reaches its own return instruction.

If it does this a googolplex number of times the simulated DDD
never reaches its own return instruction.

If HHH aborts and halts, it did it one cycle before the simulated HHH
would halt and return.
If it would have simulated the *same* input one more cycle, it would
have halted.
But i cannot simulate it one cycle longer, because it was programmed to
abort after this number of cycles.
So, this HHH's simulation of *itself* is incorrect.

If the simulation is ever aborted the simulated DDD never reaches
its own return instruction.

Only, because the simulation prevented to reach tat instruction, because
it aborts prematurely.

When we construe the halt state of DDD as its "return"
instruction then the simulated DD never halts.

That would be your dream of a HHH that does not halt.
But dreams are no substitute for facts.
HHH *does* abort after N cycles. When it does so, the simulated HHH has
done only N-1 cycles. It needs one more cycle.
So, the simulation skipped the last cycle of a halting program,
deviating from the semantics of the x86 language, which makes the
simulation incorrect.
HHH cannot possibly simulate itself correctly.
It really is not that difficult to understand.

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

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

On 8/3/2024 9:04 AM, Fred. Zwarts wrote:

Op 03.aug.2024 om 15:50 schreef olcott:

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

Op 02.aug.2024 om 22:57 schreef olcott:

Who here is too stupid to know that DDD correctly simulated
by HHH cannot possibly reach its own return instruction?

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

Which proves that the simulation is incorrect.

When are you going to understand that you are not allowed
to disagree with the semantics of the x86 language?

I do not disagree.
When are you going to understand that it is a deviation of the
semantics of the x86 language to skip instructions of a halting program,

HHH(DDD) simulates DDD that calls HHH(DDD) to repeat the process.

If it does this an infinite number of times the simulated DDD
never reaches its own return instruction.

If it does this a googolplex number of times the simulated DDD
never reaches its own return instruction.

Nope, the PARTIAL SIMULATION of DDD never reaches the return instruction.

The actual program DDD, that was being simulated does, after the HHH
that it calls aborts and returns.

If the simulation is ever aborted the simulated DDD never reaches
its own return instruction.

Nope, the PARTIAL SIMULATION of DDD never reaches the return instruction.

The actual program DDD, that was being simulated does, after the HHH
that it calls aborts and returns.

When we construe the halt state of DDD as its "return"
instruction then the simulated DD never halts.

Nope, the PARTIAL SIMULATION of DDD never reaches the return instruction.

The actual program DDD, that was being simulated does, after the HHH
that it calls aborts and returns.

Your problem is you confuse the partial simulation done by HHH as the
actual behavior of the program described by the input, which is actually
what the direct execution does.

The fact that you can not understand this difference just proves your
logical stupidity about programs. You have brainwashed yourself to not
be able to see the correct answer, making yourself into a pathetic
ignorant pathological lying idiot who recklessly disregards the truth
becuas he refuses to look at it.

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

On 8/3/24 12:03 PM, olcott wrote:

On 8/3/2024 10:33 AM, Richard Damon wrote:

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

On 8/3/2024 9:04 AM, Fred. Zwarts wrote:

Op 03.aug.2024 om 15:50 schreef olcott:

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

Op 02.aug.2024 om 22:57 schreef olcott:

Who here is too stupid to know that DDD correctly simulated
by HHH cannot possibly reach its own return instruction?

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

Which proves that the simulation is incorrect.

When are you going to understand that you are not allowed
to disagree with the semantics of the x86 language?

I do not disagree.
When are you going to understand that it is a deviation of the
semantics of the x86 language to skip instructions of a halting
program,

HHH(DDD) simulates DDD that calls HHH(DDD) to repeat the process.

If it does this an infinite number of times the simulated DDD
never reaches its own return instruction.

If it does this a googolplex number of times the simulated DDD
never reaches its own return instruction.

Nope, the PARTIAL SIMULATION of DDD never reaches the return instruction.

For N = 0; while N <= googolplex; N++
N instructions of DDD correctly emulated by HHH[N] never
reach their own "return" instruction final state.

∞ instructions of DDD correctly emulated by HHH[∞] never
reach their own "return" instruction final state.

Thus any HHH that takes a wild guess that DDD emulated
by itself never halts is always correct.

The SIMULATION of DDD never reaches the return instruction.

The actual Program DDD that HHH simulates, WILL reach its final
instruction for ANY FINITE N, as it will call that HHH, which will
simulate for the finite time to emulate N instructions and return to DDD
which will return.

Any HHH that returns, had to have done that, so the correct answer for
any DDD based on an HHH that returns is that the DDD Halts.

That you are so stuck on your error of confusing the emulation of DDD by
HHH with the actual behavior of DDD just proves you are nothing but a
MORON, and a LIAR,

Sorry, just repeating you lies just adds proof to that conclusion.

You just don't know what you are talking about, and have proved in in an uncounted multiple of ways.

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

Op 03.aug.2024 om 18:03 schreef olcott:

On 8/3/2024 10:33 AM, Richard Damon wrote:

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

On 8/3/2024 9:04 AM, Fred. Zwarts wrote:

Op 03.aug.2024 om 15:50 schreef olcott:

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

Op 02.aug.2024 om 22:57 schreef olcott:

Who here is too stupid to know that DDD correctly simulated
by HHH cannot possibly reach its own return instruction?

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

Which proves that the simulation is incorrect.

When are you going to understand that you are not allowed
to disagree with the semantics of the x86 language?

I do not disagree.
When are you going to understand that it is a deviation of the
semantics of the x86 language to skip instructions of a halting
program,

HHH(DDD) simulates DDD that calls HHH(DDD) to repeat the process.

If it does this an infinite number of times the simulated DDD
never reaches its own return instruction.

If it does this a googolplex number of times the simulated DDD
never reaches its own return instruction.

Nope, the PARTIAL SIMULATION of DDD never reaches the return instruction.

For N = 0; while N <= googolplex; N++
N instructions of DDD correctly emulated by HHH[N] never
reach their own "return" instruction final state.

Proving that for each N the simulation is incomplete and therefore
incorrect.

∞ instructions of DDD correctly emulated by HHH[∞] never
reach their own "return" instruction final state.

Proving that HHH cannot possibly simulate *itself* correctly.

Thus any HHH that takes a wild guess that DDD emulated
by itself never halts is always correct.

No, it proves that HHH cannot possibly simulate itself correctly. All
HHH that abort are incorrect because they abort one cycle before the
simulation of a halting program would halt. The HHH that does not abort
is incorrect because it does not halt.

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

Op 03.aug.2024 om 17:20 schreef olcott:

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

Op 03.aug.2024 om 16:37 schreef olcott:

On 8/3/2024 9:08 AM, Fred. Zwarts wrote:

Op 03.aug.2024 om 15:58 schreef olcott:

On 8/3/2024 3:19 AM, Mikko wrote:

On 2024-08-02 20:57:26 +0000, olcott said:

Who here is too stupid to know that DDD correctly simulated
by HHH cannot possibly reach its own return instruction?

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

Everyone here understands that that depends on whther HHH returns. >>>>>>

Fred's understanding is worse than that.
Some have deeper understanding than that.

*Ben has the best understanding of all*

On 10/14/2022 7:44 PM, Ben Bacarisse wrote:

I don't think that is the shell game.  PO really /has/ an H
(it's trivial to do for this one case) that correctly determines >>>>>  > that P(P) *would* never stop running *unless* aborted.

...

But H determines (correctly) that D would not halt if it
were not halted.  That much is a truism.

we are talking about H that aborts and halts.
Dreaming of a HHH that does not halt if it were no halted may be
relaxing, but it is completely irrelevant.
Olcott still does not understand that such dreams have no effect on
the coded HHH that is programmed to abort and halt.
When it halts it halts, but that is already too difficult for olcott.
He keeps dreaming of HHH that does not halt.

*Ben's understanding is correct yours is incorrect*
Ben's understanding refers to applying this criteria
to the following code where H(D,D) halts.

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

You can repeat this irrelevant quote many more times, but it is
irrelevant, because it speaks about a correct simulation and HHH's
simulation of itself is incorrect.
The simulation of a halting program halts.
That is a tautology in your terms. Disagreeing with it is denying a
truism.
HHH halts, because it is coded to abort and halt.

int D(int (*x)())
{
   int Halt_Status = H(x, x);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

int main()
{
   H(D,D);
}

In the above code D correctly simulated by H cannot possibly

Still no evidence for your claim.
You may wish very, very much that it is correct. You can repeat many,
many times the word 'correctly'. But it does not make it correct.

reach its own second instruction, thus cannot possibly reach
its own halt state of "return".

Proving that the simulation is incorrect.

When you try to show how DDD simulated by HHH does
reach its "return" instruction you must necessarily
must fail unless you cheat by disagreeing with the
semantics of C. That you fail to have a sufficient
understanding of the semantics of C is less than no
rebuttal what-so-ever.

Fortunately that is not what I try, because I understand that HHH cannot possibly simulate itself correctly.

Anyone trying to simulate HHH by itself fails, because it must deviate
from the semantics of the x86 language.

Dreaming that a program that deviates from the semantics is still
correct are no substitute for facts.

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

On 2024-08-03 13:58:07 +0000, olcott said:

On 8/3/2024 3:19 AM, Mikko wrote:

On 2024-08-02 20:57:26 +0000, olcott said:

Who here is too stupid to know that DDD correctly simulated
by HHH cannot possibly reach its own return instruction?

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

Everyone here understands that that depends on whther HHH returns.

Fred's understanding is worse than that.

You don't know whether that is true.

Some have deeper understanding than that.

*Ben has the best understanding of all*

In particular better than you.

--
Mikko

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

On 8/4/24 9:11 AM, olcott wrote:

On 8/4/2024 1:26 AM, Fred. Zwarts wrote:

Op 03.aug.2024 om 17:20 schreef olcott:>>

When you try to show how DDD simulated by HHH does
reach its "return" instruction you must necessarily
must fail unless you cheat by disagreeing with the
semantics of C. That you fail to have a sufficient
understanding of the semantics of C is less than no
rebuttal what-so-ever.

Fortunately that is not what I try, because I understand that HHH
cannot possibly simulate itself correctly.

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

In other words when HHH simulates itself simulating DDD it
is supposed to do something other than simulating itself
simulating DDD ???  Do you expect it to make a cup of coffee?

No, but to be correct it need to complete that to the end.

Of course to do that you need to find some N that is greater than N+1,
which is an impossible task.

Thus, HHH can not correctly emulate itself.

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

On 8/4/2024 1:54 PM, Richard Damon wrote:

On 8/4/24 9:11 AM, olcott wrote:

On 8/4/2024 1:26 AM, Fred. Zwarts wrote:

Op 03.aug.2024 om 17:20 schreef olcott:>>

When you try to show how DDD simulated by HHH does
reach its "return" instruction you must necessarily
must fail unless you cheat by disagreeing with the
semantics of C. That you fail to have a sufficient
understanding of the semantics of C is less than no
rebuttal what-so-ever.

Fortunately that is not what I try, because I understand that HHH
cannot possibly simulate itself correctly.

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

In other words when HHH simulates itself simulating DDD it
is supposed to do something other than simulating itself
simulating DDD ???  Do you expect it to make a cup of coffee?

No, but to be correct it need to complete that to the end.

Saying this and knowing there is no end cannot possibly
be construed as anything but intentional deception.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

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

On 8/4/24 3:00 PM, olcott wrote:

On 8/4/2024 1:54 PM, Richard Damon wrote:

On 8/4/24 9:11 AM, olcott wrote:

On 8/4/2024 1:26 AM, Fred. Zwarts wrote:

Op 03.aug.2024 om 17:20 schreef olcott:>>

When you try to show how DDD simulated by HHH does
reach its "return" instruction you must necessarily
must fail unless you cheat by disagreeing with the
semantics of C. That you fail to have a sufficient
understanding of the semantics of C is less than no
rebuttal what-so-ever.

Fortunately that is not what I try, because I understand that HHH
cannot possibly simulate itself correctly.

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

In other words when HHH simulates itself simulating DDD it
is supposed to do something other than simulating itself
simulating DDD ???  Do you expect it to make a cup of coffee?

No, but to be correct it need to complete that to the end.

Saying this and knowing there is no end cannot possibly
be construed as anything but intentional deception.

You can completely count the Natural Numbers, if you allow yourself to continually count without ending.

That is the nature of Countable Infinity.

Sorry, you re just proving your ignorance of the topic.

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

On 2024-08-04 13:11:56 +0000, olcott said:

On 8/4/2024 1:26 AM, Fred. Zwarts wrote:

Op 03.aug.2024 om 17:20 schreef olcott:>>

When you try to show how DDD simulated by HHH does
reach its "return" instruction you must necessarily
must fail unless you cheat by disagreeing with the
semantics of C. That you fail to have a sufficient
understanding of the semantics of C is less than no
rebuttal what-so-ever.

Fortunately that is not what I try, because I understand that HHH
cannot possibly simulate itself correctly.

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

In other words when HHH simulates itself simulating DDD it
is supposed to do something other than simulating itself
simulating DDD ??? Do you expect it to make a cup of coffee?

In another message you have said that when HHH simulates itself
simulating DDD is does not simulate itself simulating itself
simulating DDD. You have not told whether it makes a cup of coffee.
Neither action can be seen in the traces you have shown.

--
Mikko

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

On 2024-08-04 12:37:49 +0000, olcott said:

On 8/4/2024 2:18 AM, Mikko wrote:

On 2024-08-03 13:58:07 +0000, olcott said:

On 8/3/2024 3:19 AM, Mikko wrote:

On 2024-08-02 20:57:26 +0000, olcott said:

Who here is too stupid to know that DDD correctly simulated
by HHH cannot possibly reach its own return instruction?

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

Everyone here understands that that depends on whther HHH returns.

Fred's understanding is worse than that.

You don't know whether that is true.

Some have deeper understanding than that.

*Ben has the best understanding of all*

In particular better than you.

*Ben has a deeper agreement with me than anyone else*

Doesn't matter. Points of disagreement, both deep and shallow, are
more important than points of agreement.

--
Mikko

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

On 8/5/2024 2:49 AM, Mikko wrote:

On 2024-08-04 12:37:49 +0000, olcott said:

On 8/4/2024 2:18 AM, Mikko wrote:

On 2024-08-03 13:58:07 +0000, olcott said:

On 8/3/2024 3:19 AM, Mikko wrote:

On 2024-08-02 20:57:26 +0000, olcott said:

Who here is too stupid to know that DDD correctly simulated
by HHH cannot possibly reach its own return instruction?

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

Everyone here understands that that depends on whther HHH returns.

Fred's understanding is worse than that.

You don't know whether that is true.

Some have deeper understanding than that.

*Ben has the best understanding of all*

In particular better than you.

*Ben has a deeper agreement with me than anyone else*

Doesn't matter. Points of disagreement, both deep and shallow, are
more important than points of agreement.

Not at all.
Most of the reviewers simply don't have a clue that they
don't have a clue. The error is entirely on their side.

--
Copyright 2024 Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

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

On 8/5/2024 2:44 AM, Mikko wrote:

On 2024-08-04 13:11:56 +0000, olcott said:

On 8/4/2024 1:26 AM, Fred. Zwarts wrote:

Op 03.aug.2024 om 17:20 schreef olcott:>>

When you try to show how DDD simulated by HHH does
reach its "return" instruction you must necessarily
must fail unless you cheat by disagreeing with the
semantics of C. That you fail to have a sufficient
understanding of the semantics of C is less than no
rebuttal what-so-ever.

Fortunately that is not what I try, because I understand that HHH
cannot possibly simulate itself correctly.

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

In other words when HHH simulates itself simulating DDD it
is supposed to do something other than simulating itself
simulating DDD ???  Do you expect it to make a cup of coffee?

In another message you have said that when HHH simulates itself
simulating DDD is does not simulate itself simulating itself
simulating DDD. You have not told whether it makes a cup of coffee.
Neither action can be seen in the traces you have shown.

HHH and HH and the original H have proved that they simulate
themselves simulating DDD, DD and P for three years now.

They did this by deriving the correct execution trace that
simulating themselves simulating their input would derive.

Maybe all of my reviewers have been saying that I am wrong
about this on the basis of pure bluster in that they are
totally confused by assembly language and don't have the
slightest clue what it means.

--
Copyright 2024 Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

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

On 2024-08-05 15:01:36 +0000, olcott said:

On 8/5/2024 2:49 AM, Mikko wrote:

On 2024-08-04 12:37:49 +0000, olcott said:

On 8/4/2024 2:18 AM, Mikko wrote:

On 2024-08-03 13:58:07 +0000, olcott said:

On 8/3/2024 3:19 AM, Mikko wrote:

On 2024-08-02 20:57:26 +0000, olcott said:

Who here is too stupid to know that DDD correctly simulated
by HHH cannot possibly reach its own return instruction?

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

Everyone here understands that that depends on whther HHH returns.

Fred's understanding is worse than that.

You don't know whether that is true.

Some have deeper understanding than that.

*Ben has the best understanding of all*

In particular better than you.

*Ben has a deeper agreement with me than anyone else*

Doesn't matter. Points of disagreement, both deep and shallow, are
more important than points of agreement.

Not at all.
Most of the reviewers simply don't have a clue that they
don't have a clue. The error is entirely on their side.

Your reviewers don't need a clue. You need. But you don't have.
And you don't know you don't have so you don't seek. As you
don't seek you will never get.

--
Mikko

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

On 2024-08-05 15:00:12 +0000, olcott said:

On 8/5/2024 2:44 AM, Mikko wrote:

On 2024-08-04 13:11:56 +0000, olcott said:

On 8/4/2024 1:26 AM, Fred. Zwarts wrote:

Op 03.aug.2024 om 17:20 schreef olcott:>>

When you try to show how DDD simulated by HHH does
reach its "return" instruction you must necessarily
must fail unless you cheat by disagreeing with the
semantics of C. That you fail to have a sufficient
understanding of the semantics of C is less than no
rebuttal what-so-ever.

Fortunately that is not what I try, because I understand that HHH
cannot possibly simulate itself correctly.

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

In other words when HHH simulates itself simulating DDD it
is supposed to do something other than simulating itself
simulating DDD ???  Do you expect it to make a cup of coffee?

In another message you have said that when HHH simulates itself
simulating DDD is does not simulate itself simulating itself
simulating DDD. You have not told whether it makes a cup of coffee.
Neither action can be seen in the traces you have shown.

HHH and HH and the original H have proved that they simulate
themselves simulating DDD, DD and P for three years now.

Your trace don't show siulation of exectuion differently from
simulation of simulation of execution.

--
Mikko

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

Op 04.aug.2024 om 21:00 schreef olcott:

On 8/4/2024 1:54 PM, Richard Damon wrote:

On 8/4/24 9:11 AM, olcott wrote:

On 8/4/2024 1:26 AM, Fred. Zwarts wrote:

Op 03.aug.2024 om 17:20 schreef olcott:>>

When you try to show how DDD simulated by HHH does
reach its "return" instruction you must necessarily
must fail unless you cheat by disagreeing with the
semantics of C. That you fail to have a sufficient
understanding of the semantics of C is less than no
rebuttal what-so-ever.

Fortunately that is not what I try, because I understand that HHH
cannot possibly simulate itself correctly.

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

In other words when HHH simulates itself simulating DDD it
is supposed to do something other than simulating itself
simulating DDD ???  Do you expect it to make a cup of coffee?

No, but to be correct it need to complete that to the end.

Saying this and knowing there is no end cannot possibly
be construed as anything but intentional deception.

And what is saying that there is no end for a program that aborts and
halts after two cycles? Are you dreaming again of the non-aborting HHH
that does not halt? Dreams are no substitute for facts.

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

Op 04.aug.2024 om 15:11 schreef olcott:

On 8/4/2024 1:26 AM, Fred. Zwarts wrote:

Op 03.aug.2024 om 17:20 schreef olcott:>>

When you try to show how DDD simulated by HHH does
reach its "return" instruction you must necessarily
must fail unless you cheat by disagreeing with the
semantics of C. That you fail to have a sufficient
understanding of the semantics of C is less than no
rebuttal what-so-ever.

Fortunately that is not what I try, because I understand that HHH
cannot possibly simulate itself correctly.

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

In other words when HHH simulates itself simulating DDD it
is supposed to do something other than simulating itself
simulating DDD ???  Do you expect it to make a cup of coffee?

Is English too difficult for you. I said HHH cannot do it correctly. HHH
is supposed to do it correctly, but it cannot do it correctly.
Are you caught in thinking that it can do it correctly? It cannot do it correctly. So, assuming it does it correctly is incorrect.
Stop talking about what else it should do, it cannot do it correctly.

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

On 8/7/2024 3:16 AM, Fred. Zwarts wrote:

Op 04.aug.2024 om 15:11 schreef olcott:

On 8/4/2024 1:26 AM, Fred. Zwarts wrote:

Op 03.aug.2024 om 17:20 schreef olcott:>>

When you try to show how DDD simulated by HHH does
reach its "return" instruction you must necessarily
must fail unless you cheat by disagreeing with the
semantics of C. That you fail to have a sufficient
understanding of the semantics of C is less than no
rebuttal what-so-ever.

Fortunately that is not what I try, because I understand that HHH
cannot possibly simulate itself correctly.

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

In other words when HHH simulates itself simulating DDD it
is supposed to do something other than simulating itself
simulating DDD ???  Do you expect it to make a cup of coffee?

Is English too difficult for you. I said HHH cannot do it correctly.

*According to an incorrect criteria of correct*
You keep trying to get away with disagreeing with
the semantics of the x86 language. *That is not allowed*

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

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

On 8/7/2024 3:18 AM, Fred. Zwarts wrote:

Op 04.aug.2024 om 21:00 schreef olcott:

On 8/4/2024 1:54 PM, Richard Damon wrote:

On 8/4/24 9:11 AM, olcott wrote:

On 8/4/2024 1:26 AM, Fred. Zwarts wrote:

Op 03.aug.2024 om 17:20 schreef olcott:>>

When you try to show how DDD simulated by HHH does
reach its "return" instruction you must necessarily
must fail unless you cheat by disagreeing with the
semantics of C. That you fail to have a sufficient
understanding of the semantics of C is less than no
rebuttal what-so-ever.

Fortunately that is not what I try, because I understand that HHH
cannot possibly simulate itself correctly.

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

In other words when HHH simulates itself simulating DDD it
is supposed to do something other than simulating itself
simulating DDD ???  Do you expect it to make a cup of coffee?

No, but to be correct it need to complete that to the end.

Saying this and knowing there is no end cannot possibly
be construed as anything but intentional deception.

And what is saying that there is no end for a program that aborts and

void Infinite_Recursion()
{
Infinite_Recursion();
return;
}

Unless we divide the behavior of the tester from the test
subject Infinite_Recursion() would be determined to halt.

Instead we define the "return" as the never reached halt
state of Infinite_Recursion().

halts after two cycles? Are you dreaming again of the non-aborting HHH
that does not halt? Dreams are no substitute for facts.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

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

On 8/7/2024 2:22 AM, Mikko wrote:

On 2024-08-05 15:00:12 +0000, olcott said:

On 8/5/2024 2:44 AM, Mikko wrote:

On 2024-08-04 13:11:56 +0000, olcott said:

On 8/4/2024 1:26 AM, Fred. Zwarts wrote:

Op 03.aug.2024 om 17:20 schreef olcott:>>

When you try to show how DDD simulated by HHH does
reach its "return" instruction you must necessarily
must fail unless you cheat by disagreeing with the
semantics of C. That you fail to have a sufficient
understanding of the semantics of C is less than no
rebuttal what-so-ever.

Fortunately that is not what I try, because I understand that HHH
cannot possibly simulate itself correctly.

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

In other words when HHH simulates itself simulating DDD it
is supposed to do something other than simulating itself
simulating DDD ???  Do you expect it to make a cup of coffee?

In another message you have said that when HHH simulates itself
simulating DDD is does not simulate itself simulating itself
simulating DDD. You have not told whether it makes a cup of coffee.
Neither action can be seen in the traces you have shown.

HHH and HH and the original H have proved that they simulate
themselves simulating DDD, DD and P for three years now.

Your trace don't show siulation of exectuion differently from
simulation of simulation of execution.

It does but it is too difficult to dig it out of emulations
of emulators emulating inputs.

You can go in there and highlight all of the instructions
of the first emulated DDD in yellow, the second DDD in cyan,
the first HHH in red and the second HHH in green.

As soon as the first HHH sees the second DDD about to invoke
a third HHH it aborts the emulation. At this point DDD, the
second HHH and the second DDD all immediately stop running
and HHH returns 0 to main.

https://liarparadox.org/HHH(DDD)_Full_Trace.pdf

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

No actual need to go through all that tediousness. Any expert
in the C language that knows what x86 emulators are knows
the DDD correctly emulated by HHH specifies what is essentially
equivalent to infinite recursion. It seems that no one here
has that degree of expertise.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

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

Le 07/08/2024 à 15:40, olcott a écrit :

[snip nonsense] It seems that no one here has that degree of expertise.

Come on Peter! This is ridiculous.

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

On 8/7/2024 2:24 AM, Mikko wrote:

On 2024-08-05 15:01:36 +0000, olcott said:

On 8/5/2024 2:49 AM, Mikko wrote:

On 2024-08-04 12:37:49 +0000, olcott said:

On 8/4/2024 2:18 AM, Mikko wrote:

On 2024-08-03 13:58:07 +0000, olcott said:

On 8/3/2024 3:19 AM, Mikko wrote:

On 2024-08-02 20:57:26 +0000, olcott said:

Who here is too stupid to know that DDD correctly simulated
by HHH cannot possibly reach its own return instruction?

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

Everyone here understands that that depends on whther HHH returns. >>>>>>

Fred's understanding is worse than that.

You don't know whether that is true.

Some have deeper understanding than that.

*Ben has the best understanding of all*

In particular better than you.

*Ben has a deeper agreement with me than anyone else*

Doesn't matter. Points of disagreement, both deep and shallow, are
more important than points of agreement.

Not at all.
Most of the reviewers simply don't have a clue that they
don't have a clue. The error is entirely on their side.

Your reviewers don't need a clue. You need. But you don't have.
And you don't know you don't have so you don't seek. As you
don't seek you will never get.

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

Any expert in the C language that knows what x86 emulators
are knows that DDD correctly emulated by HHH specifies what
is essentially equivalent to infinite recursion.

It seems that no one here has that degree of expertise.
That they know that they don't understand these things
and still say that I am wrong is dishonest.


--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

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

On 8/7/2024 8:42 AM, Python wrote:

Le 07/08/2024 à 15:40, olcott a écrit :

[snip nonsense] It seems that no one here has that degree of expertise.

Come on Peter! This is ridiculous.

The bluster of pure rhetoric because no rebuttal
based on correct reasoning actually exists.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

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

On 8/7/24 9:56 AM, olcott wrote:

On 8/7/2024 8:42 AM, Python wrote:

Le 07/08/2024 à 15:40, olcott a écrit :

[snip nonsense] It seems that no one here has that degree of expertise.

Come on Peter! This is ridiculous.

The bluster of pure rhetoric because no rebuttal
based on correct reasoning actually exists.

No, you are just projecting just like your model Rump.

YOU are the one that just uses rhetoric, as you have no actual knowledge
to base an argument on, but just make you baseless claims that you have
been unable to support, PROVING that you are just a pathological liar.

Your "logic" is just like the election deniers that you claim to be
combatting, but your actions just validate what they are doing.

Sorry, but that IS the Truth.

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

On 2024-08-07 13:19:33 +0000, olcott said:

On 8/7/2024 3:18 AM, Fred. Zwarts wrote:

Op 04.aug.2024 om 21:00 schreef olcott:

On 8/4/2024 1:54 PM, Richard Damon wrote:

On 8/4/24 9:11 AM, olcott wrote:

On 8/4/2024 1:26 AM, Fred. Zwarts wrote:

Op 03.aug.2024 om 17:20 schreef olcott:>>

When you try to show how DDD simulated by HHH does
reach its "return" instruction you must necessarily
must fail unless you cheat by disagreeing with the
semantics of C. That you fail to have a sufficient
understanding of the semantics of C is less than no
rebuttal what-so-ever.

Fortunately that is not what I try, because I understand that HHH
cannot possibly simulate itself correctly.

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

In other words when HHH simulates itself simulating DDD it
is supposed to do something other than simulating itself
simulating DDD ???  Do you expect it to make a cup of coffee?

No, but to be correct it need to complete that to the end.

Saying this and knowing there is no end cannot possibly
be construed as anything but intentional deception.

And what is saying that there is no end for a program that aborts and

void Infinite_Recursion()
{
Infinite_Recursion();
return;
}

Unless we divide the behavior of the tester from the test
subject Infinite_Recursion() would be determined to halt.

Is that false or non-sense? I can only determine that it is not true.

--
Mikko

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

On 2024-08-07 13:42:07 +0000, Python said:

Le 07/08/2024 à 15:40, olcott a écrit :

[snip nonsense] It seems that no one here has that degree of expertise.

Come on Peter! This is ridiculous.

Not at all if "here" means the place where Olcott is and he
is alone there.

--
Mikko

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

On 2024-08-07 13:43:09 +0000, olcott said:

On 8/7/2024 2:24 AM, Mikko wrote:

On 2024-08-05 15:01:36 +0000, olcott said:

On 8/5/2024 2:49 AM, Mikko wrote:

On 2024-08-04 12:37:49 +0000, olcott said:

On 8/4/2024 2:18 AM, Mikko wrote:

On 2024-08-03 13:58:07 +0000, olcott said:

On 8/3/2024 3:19 AM, Mikko wrote:

On 2024-08-02 20:57:26 +0000, olcott said:

Who here is too stupid to know that DDD correctly simulated
by HHH cannot possibly reach its own return instruction?

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

Everyone here understands that that depends on whther HHH returns. >>>>>>>

Fred's understanding is worse than that.

You don't know whether that is true.

Some have deeper understanding than that.

*Ben has the best understanding of all*

In particular better than you.

*Ben has a deeper agreement with me than anyone else*

Doesn't matter. Points of disagreement, both deep and shallow, are
more important than points of agreement.

Not at all.
Most of the reviewers simply don't have a clue that they
don't have a clue. The error is entirely on their side.

Your reviewers don't need a clue. You need. But you don't have.
And you don't know you don't have so you don't seek. As you
don't seek you will never get.

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

Any expert in the C language that knows what x86 emulators
are knows that DDD correctly emulated by HHH specifies what
is essentially equivalent to infinite recursion.

No, that requires knowing what does or at least whther it
ever returns. Knowledge of what x86 emulators are does not
help.

--
Mikko

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

Op 07.aug.2024 om 15:01 schreef olcott:

On 8/7/2024 3:16 AM, Fred. Zwarts wrote:

Op 04.aug.2024 om 15:11 schreef olcott:

On 8/4/2024 1:26 AM, Fred. Zwarts wrote:

Op 03.aug.2024 om 17:20 schreef olcott:>>

When you try to show how DDD simulated by HHH does
reach its "return" instruction you must necessarily
must fail unless you cheat by disagreeing with the
semantics of C. That you fail to have a sufficient
understanding of the semantics of C is less than no
rebuttal what-so-ever.

Fortunately that is not what I try, because I understand that HHH
cannot possibly simulate itself correctly.

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

In other words when HHH simulates itself simulating DDD it
is supposed to do something other than simulating itself
simulating DDD ???  Do you expect it to make a cup of coffee?

Is English too difficult for you. I said HHH cannot do it correctly.

*According to an incorrect criteria of correct*
You keep trying to get away with disagreeing with
the semantics of the x86 language. *That is not allowed*

Again accusations without evidence.
We proved that HHH deviated from the semantics of the x86 language by
skipping the last few instructions of a halting program.
This is incorrect, even according to your own definition of 'correct'.
No matter how much olcott wants it to be correct, or how many times
olcott repeats that it is correct, it does not change the fact that such
a simulation is incorrect, because it is unable to reach the end of a
halting program.
Olcott's own claim that the simulated HHH does not reach its end
confirms it. The trace he has shown also proves that HHH cannot reach
the end of its own simulation. So, his own claims prove that it is true
that HHH cannot possibly simulate itself up to the end, which makes the simulation incomplete and, therefore, incorrect.
Dreams are no substitute for logic proofs.

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