From Newsgroup: sci.logic

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

To make this easier to understand we replace line three
with the more conventional terminology this line:
"cannot possibly reach its own simulated final halt state then"

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. He knows and accepts that
P(P) actually does stop. The wrong answer is justified by what would
happen if H (and hence a different P) where not what they actually are.

Saying that H is required report on the behavior of
machine M is a category error.

Turing machines cannot directly report on the behavior
of other Turing machines they can at best indirectly
report on the behavior of Turing machines through the
proxy of finite string machine descriptions such as rf?Mrf-.

Thus the behavior specified by the input finite string
overrules and supersedes the behavior of the direct
execution.

DDD correctly simulated by HHH cannot possibly
reach its own simulated "return" instruction
final halt state, thus overruling and superseding
the behavior of the directly executed DDD().
--
Copyright 2024 Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: sci.logic

On 7/28/25 12:13 PM, olcott wrote:

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
-a-a-a If simulating halt decider H correctly simulates its
-a-a-a input D until H correctly determines that its simulated D
-a-a-a *would never stop running unless aborted then*

-a-a-a H can abort its simulation of D and correctly report that D
-a-a-a specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

To make this easier to understand we replace line three
with the more conventional terminology this line:
"cannot possibly reach its own simulated final halt state then"

Nope, that isn't the equivalent.

You could say: If the correct simulation of the input would never reach
a final halt state.

Note, you error in trying to make it the simulation by the decider controlling, the controlling is a CORRECT (and thus complete) simulation
of this exact input.

You also error by making the input a category error by not including the
code for the specific HHH that it calls part of it.

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

I don't think that is the shell game.-a 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.-a He knows and accepts that
P(P) actually does stop.-a The wrong answer is justified by what would
happen if H (and hence a different P) where not what they actually are.

Saying that H is required report on the behavior of
machine M is a category error.

Nope, it is the DEFINITION

I guess you are just showing you reject the actual meaning of the words,
and thus you whole concept of correct reasoning is based on lies.

Turing machines cannot directly report on the behavior
of other Turing machines they can at best indirectly
report on the behavior of Turing machines through the
proxy of finite string machine descriptions such as rf?Mrf-.

Right, and it *WAS* given a finite string representation, whose correct simulatin (which HHH doesn't do) exactly reproduces.

Thus the behavior specified by the input finite string
overrules and supersedes the behavior of the direct
execution.

But that behavior is exactly the behavior of the program it represents.

Anything else is just al LIE.

DDD correctly simulated by HHH cannot possibly
reach its own simulated "return" instruction
final halt state, thus overruling and superseding
the behavior of the directly executed DDD().

But your HHH doesn't correctly simulate its DDD.

And, becuase you don't include all of the program of DDD in your representation, it CAN'T be correctly simulated.

All comments about correct simulation I have made assume this is fixed
by including that needed code. which of course means no other
hypothetical HHH is given the same DDD by you arguments, and thus is irrelevent.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: sci.logic

Many times already olcott has claimed to have a proof.
Each time again it turned out that there was no proof.

Op 28.jul.2025 om 18:13 schreef olcott:

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
-a-a-a If simulating halt decider H correctly simulates its
-a-a-a input D until H correctly determines that its simulated D
-a-a-a *would never stop running unless aborted then*

-a-a-a H can abort its simulation of D and correctly report that D
-a-a-a specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

To make this easier to understand we replace line three
with the more conventional terminology this line:
"cannot possibly reach its own simulated final halt state then"

Which changes the meaning of the sentence, so you can no longer claim
that Sipser agreed to it.

In addition not-reaching the halt state can have more reasons than a non-halting sequence of instructions. E.g.: a computer being switched
off, a simulation aborted.

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

I don't think that is the shell game.-a 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.-a He knows and accepts that
P(P) actually does stop.-a The wrong answer is justified by what would
happen if H (and hence a different P) where not what they actually are.

Saying that H is required report on the behavior of
machine M is a category error.

Turing machines cannot directly report on the behavior
of other Turing machines they can at best indirectly
report on the behavior of Turing machines through the
proxy of finite string machine descriptions such as rf?Mrf-.

Thus the behavior specified by the input finite string
overrules and supersedes the behavior of the direct
execution.

No, because there is no difference between the specification of the
input and the direct execution. At most there is a difference between
what the simulator sees and the specification. But that indicates an
error in the simulator, not a change in the specification.

DDD correctly simulated by HHH cannot possibly
reach its own simulated "return" instruction
final halt state, thus overruling and superseding
the behavior of the directly executed DDD().

So, not possible to reach the final halt state can also bee a failure of
the simulator. That is the case in HHH.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: sci.logic

On 7/29/2025 3:37 AM, Fred. Zwarts wrote:

Many times already olcott has claimed to have a proof.
Each time again it turned out that there was no proof.

Op 28.jul.2025 om 18:13 schreef olcott:

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D
-a-a-a-a *would never stop running unless aborted then*

-a-a-a-a H can abort its simulation of D and correctly report that D
-a-a-a-a specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

To make this easier to understand we replace line three
with the more conventional terminology this line:
"cannot possibly reach its own simulated final halt state then"

Which changes the meaning of the sentence, so you can no longer claim
that Sipser agreed to it.

Yes

In addition not-reaching the halt state can have more reasons than a non-halting sequence of instructions. E.g.: a computer being switched
off, a simulation aborted.

This is you not paying close enough attention to the exact
words that I exactly said.

I did not say: DOES NOT REACH ITS FINAL STATE (might have been aborted)
I said: CANNOT POSSIBLY REACH ITS FINAL STATE (aborted or not)

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

I don't think that is the shell game.-a 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.-a He knows and accepts that >>> P(P) actually does stop.-a The wrong answer is justified by what would
happen if H (and hence a different P) where not what they actually are.

Saying that H is required report on the behavior of
machine M is a category error.

Turing machines cannot directly report on the behavior
of other Turing machines they can at best indirectly
report on the behavior of Turing machines through the
proxy of finite string machine descriptions such as rf?Mrf-.

Thus the behavior specified by the input finite string
overrules and supersedes the behavior of the direct
execution.

No, because there is no difference between the specification of the
input and the direct execution.

*I have proven this to be counter-factual*

HHH(DDD) must simulate itself simulating DDD because DDD calls HHH(DDD)

HHH1(DDD) must NOT simulate itself simulating DDD because DDD DOES NOT
CALL HHH1(DDD) --- [same behavior as direct execution]
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: sci.logic

On 7/29/25 5:34 PM, olcott wrote:

On 7/29/2025 3:37 AM, Fred. Zwarts wrote:

Many times already olcott has claimed to have a proof.
Each time again it turned out that there was no proof.

Op 28.jul.2025 om 18:13 schreef olcott:

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D
-a-a-a-a *would never stop running unless aborted then*

-a-a-a-a H can abort its simulation of D and correctly report that D
-a-a-a-a specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

To make this easier to understand we replace line three
with the more conventional terminology this line:
"cannot possibly reach its own simulated final halt state then"

Which changes the meaning of the sentence, so you can no longer claim
that Sipser agreed to it.

Yes

In addition not-reaching the halt state can have more reasons than a
non-halting sequence of instructions. E.g.: a computer being switched
off, a simulation aborted.

This is you not paying close enough attention to the exact
words that I exactly said.

I did not say: DOES NOT REACH ITS FINAL STATE (might have been aborted)
I said: CANNOT POSSIBLY REACH ITS FINAL STATE (aborted or not)

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

I don't think that is the shell game.-a 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.-a He knows and accepts that >>>> P(P) actually does stop.-a The wrong answer is justified by what would >>>> happen if H (and hence a different P) where not what they actually are. >>>>

Saying that H is required report on the behavior of
machine M is a category error.

Turing machines cannot directly report on the behavior
of other Turing machines they can at best indirectly
report on the behavior of Turing machines through the
proxy of finite string machine descriptions such as rf?Mrf-.

Thus the behavior specified by the input finite string
overrules and supersedes the behavior of the direct
execution.

No, because there is no difference between the specification of the
input and the direct execution.

*I have proven this to be counter-factual*

HHH(DDD) must simulate itself simulating DDD because DDD calls HHH(DDD)

HHH1(DDD) must NOT simulate itself simulating DDD because DDD DOES NOT
CALL HHH1(DDD)-a-a --- [same behavior as direct execution]

The problem is since you HHH *DOES* abort, the input DDD is built on
that HHH, and includes THAT code, and thus if you give *THIS* input to a version of HHH that doesn't abort, it will simulate the HHH that DOES
abort, since that is what the input has in it. THus, the variant of HHH
that doesn't abort, *WILL* simulate *THIS* input to a final state.

Your argument LIED by changing the code in the input, because you LIE
about the input not containing the code of HHH. But, if it doesn't
contaiin that code, then either your HHH isn't "simulating its input" or
can't actually simulate this input, since it doesn't contain anything to simulate after the call to HHH.

That is where you make your error, and by refusing to accept that, you
just make yourself a pathological liar, showing that you don't know the meaning of the words you are using.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: sci.logic

On 7/29/2025 8:28 PM, Richard Damon wrote:

On 7/29/25 5:34 PM, olcott wrote:

On 7/29/2025 3:37 AM, Fred. Zwarts wrote:

Many times already olcott has claimed to have a proof.
Each time again it turned out that there was no proof.

Op 28.jul.2025 om 18:13 schreef olcott:

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D
-a-a-a-a *would never stop running unless aborted then*

-a-a-a-a H can abort its simulation of D and correctly report that D
-a-a-a-a specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>
To make this easier to understand we replace line three
with the more conventional terminology this line:
"cannot possibly reach its own simulated final halt state then"

Which changes the meaning of the sentence, so you can no longer claim
that Sipser agreed to it.

Yes

In addition not-reaching the halt state can have more reasons than a
non-halting sequence of instructions. E.g.: a computer being switched
off, a simulation aborted.

This is you not paying close enough attention to the exact
words that I exactly said.

I did not say: DOES NOT REACH ITS FINAL STATE (might have been aborted)
I said: CANNOT POSSIBLY REACH ITS FINAL STATE (aborted or not)

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

I don't think that is the shell game.-a 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.-a He knows and accepts >>>>> that
P(P) actually does stop.-a The wrong answer is justified by what would >>>>> happen if H (and hence a different P) where not what they actually
are.

Saying that H is required report on the behavior of
machine M is a category error.

Turing machines cannot directly report on the behavior
of other Turing machines they can at best indirectly
report on the behavior of Turing machines through the
proxy of finite string machine descriptions such as rf?Mrf-.

Thus the behavior specified by the input finite string
overrules and supersedes the behavior of the direct
execution.

No, because there is no difference between the specification of the
input and the direct execution.

*I have proven this to be counter-factual*

HHH(DDD) must simulate itself simulating DDD because DDD calls HHH(DDD)

HHH1(DDD) must NOT simulate itself simulating DDD because DDD DOES NOT
CALL HHH1(DDD)-a-a --- [same behavior as direct execution]

The problem is since you HHH *DOES* abort,

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

void Infinite_Loop()
{
HERE: goto HERE;
return;
}

As it always does as soon as it correctly determines
that there exists no N steps of correct simulation
that can possibly reach the "return" instruction final
halt state.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: sci.logic

On 7/29/25 9:36 PM, olcott wrote:

On 7/29/2025 8:28 PM, Richard Damon wrote:

On 7/29/25 5:34 PM, olcott wrote:

On 7/29/2025 3:37 AM, Fred. Zwarts wrote:

Many times already olcott has claimed to have a proof.
Each time again it turned out that there was no proof.

Op 28.jul.2025 om 18:13 schreef olcott:

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>> -a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D
-a-a-a-a *would never stop running unless aborted then*

-a-a-a-a H can abort its simulation of D and correctly report that D >>>>> -a-a-a-a specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>
To make this easier to understand we replace line three
with the more conventional terminology this line:
"cannot possibly reach its own simulated final halt state then"

Which changes the meaning of the sentence, so you can no longer
claim that Sipser agreed to it.

Yes

In addition not-reaching the halt state can have more reasons than a
non-halting sequence of instructions. E.g.: a computer being
switched off, a simulation aborted.

This is you not paying close enough attention to the exact
words that I exactly said.

I did not say: DOES NOT REACH ITS FINAL STATE (might have been aborted)
I said: CANNOT POSSIBLY REACH ITS FINAL STATE (aborted or not)

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

I don't think that is the shell game.-a 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.-a He knows and accepts >>>>>> that
P(P) actually does stop.-a The wrong answer is justified by what would >>>>>> happen if H (and hence a different P) where not what they actually >>>>>> are.

Saying that H is required report on the behavior of
machine M is a category error.

Turing machines cannot directly report on the behavior
of other Turing machines they can at best indirectly
report on the behavior of Turing machines through the
proxy of finite string machine descriptions such as rf?Mrf-.

Thus the behavior specified by the input finite string
overrules and supersedes the behavior of the direct
execution.

No, because there is no difference between the specification of the
input and the direct execution.

*I have proven this to be counter-factual*

HHH(DDD) must simulate itself simulating DDD because DDD calls HHH(DDD)

HHH1(DDD) must NOT simulate itself simulating DDD because DDD DOES
NOT CALL HHH1(DDD)-a-a --- [same behavior as direct execution]

The problem is since you HHH *DOES* abort,

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

void Infinite_Loop()
{
-a HERE: goto HERE;
-a return;
}

As it always does as soon as it correctly determines
that there exists no N steps of correct simulation
that can possibly reach the "return" instruction final
halt state.

But their is a N number of steps of the correct simulation of DDD that
cause it to halt, since HHH does abort its simulation and return 0.

That N is just bigger than the number of steps that HHH does, and thus
it can never know that result, but it is still the result of the correct simulation of the input.

It is clear you just don't understand what "correct" means, in part
because you don't understand basic terms like "truth" or "logic".

Sorry, you are just showing how stupid and ignorant you are, and that
you don't care that you don't actually know that the words you are using actually mean in this context, which is what makes you the pathological
liar you are.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: sci.logic

On 7/29/2025 8:48 PM, Richard Damon wrote:

On 7/29/25 9:36 PM, olcott wrote:

On 7/29/2025 8:28 PM, Richard Damon wrote:

On 7/29/25 5:34 PM, olcott wrote:

On 7/29/2025 3:37 AM, Fred. Zwarts wrote:

Many times already olcott has claimed to have a proof.
Each time again it turned out that there was no proof.

Op 28.jul.2025 om 18:13 schreef olcott:

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022> >>>>>> -a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D >>>>>> -a-a-a-a *would never stop running unless aborted then*

-a-a-a-a H can abort its simulation of D and correctly report that D >>>>>> -a-a-a-a specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>

To make this easier to understand we replace line three
with the more conventional terminology this line:
"cannot possibly reach its own simulated final halt state then"

Which changes the meaning of the sentence, so you can no longer
claim that Sipser agreed to it.

Yes

In addition not-reaching the halt state can have more reasons than
a non-halting sequence of instructions. E.g.: a computer being
switched off, a simulation aborted.

This is you not paying close enough attention to the exact
words that I exactly said.

I did not say: DOES NOT REACH ITS FINAL STATE (might have been aborted) >>>> I said: CANNOT POSSIBLY REACH ITS FINAL STATE (aborted or not)

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

I don't think that is the shell game.-a 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.-a He knows and
accepts that
P(P) actually does stop.-a The wrong answer is justified by what >>>>>>> would
happen if H (and hence a different P) where not what they
actually are.

Saying that H is required report on the behavior of
machine M is a category error.

Turing machines cannot directly report on the behavior
of other Turing machines they can at best indirectly
report on the behavior of Turing machines through the
proxy of finite string machine descriptions such as rf?Mrf-.

Thus the behavior specified by the input finite string
overrules and supersedes the behavior of the direct
execution.

No, because there is no difference between the specification of the >>>>> input and the direct execution.

*I have proven this to be counter-factual*

HHH(DDD) must simulate itself simulating DDD because DDD calls HHH(DDD) >>>>
HHH1(DDD) must NOT simulate itself simulating DDD because DDD DOES
NOT CALL HHH1(DDD)-a-a --- [same behavior as direct execution]

The problem is since you HHH *DOES* abort,

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

void Infinite_Loop()
{
-a-a HERE: goto HERE;
-a-a return;
}

As it always does as soon as it correctly determines
that there exists no N steps of correct simulation
that can possibly reach the "return" instruction final
halt state.

But their is a N number of steps of the correct simulation of DDD that
cause it to halt,

Again you are a fucking liar. You know that halting is
reaching a final halt state and nothing else is halting.
When 0 to infinity steps of DDD are correctly simulated
by HHH no simulated DDD ever halts.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: sci.logic

Op 29.jul.2025 om 23:34 schreef olcott:

On 7/29/2025 3:37 AM, Fred. Zwarts wrote:

Many times already olcott has claimed to have a proof.
Each time again it turned out that there was no proof.

Op 28.jul.2025 om 18:13 schreef olcott:

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D
-a-a-a-a *would never stop running unless aborted then*

-a-a-a-a H can abort its simulation of D and correctly report that D
-a-a-a-a specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

To make this easier to understand we replace line three
with the more conventional terminology this line:
"cannot possibly reach its own simulated final halt state then"

Which changes the meaning of the sentence, so you can no longer claim
that Sipser agreed to it.

Yes

In addition not-reaching the halt state can have more reasons than a
non-halting sequence of instructions. E.g.: a computer being switched
off, a simulation aborted.

This is you not paying close enough attention to the exact
words that I exactly said.

I did not say: DOES NOT REACH ITS FINAL STATE (might have been aborted)
I said: CANNOT POSSIBLY REACH ITS FINAL STATE (aborted or not)

Yes it cannot possibly reach its final halt state, because it is
programmed to do a premature abort. A program cannot possibly do
something else that what the code specifies. In this case a premature
abort, preventing the simulated program to reach its final halt state.
When the simulated program is prevented to reach its final halt state,
that does not indicate non-halting behaviour of the program, only the
failure of the simulation and the 'detection' of non-halting.

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

I don't think that is the shell game.-a 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.-a He knows and accepts that >>>> P(P) actually does stop.-a The wrong answer is justified by what would >>>> happen if H (and hence a different P) where not what they actually are. >>>>

Saying that H is required report on the behavior of
machine M is a category error.

Turing machines cannot directly report on the behavior
of other Turing machines they can at best indirectly
report on the behavior of Turing machines through the
proxy of finite string machine descriptions such as rf?Mrf-.

Thus the behavior specified by the input finite string
overrules and supersedes the behavior of the direct
execution.

No, because there is no difference between the specification of the
input and the direct execution.

*I have proven this to be counter-factual*

No, you dreamed about it. That is not a proof. If it were true, you
could show us the instruction that is correctly simulated differently
from the direct execution. The only thing the traces show is that the simulation fails the correct simulation of a instruction when it does
not continue with the next one, violating the x86 language.

HHH(DDD) must simulate itself simulating DDD because DDD calls HHH(DDD)

This 'itself' is HHH.

HHH1(DDD) must NOT simulate itself simulating DDD because DDD DOES NOT
CALL HHH1(DDD)-a-a --- [same behavior as direct execution]

Indeed, HHH1 must not simulate something different, but the same thing
as HHH tries to simulate: HHH.
(Your back is the same back that other people see, even if it is not
their back.)

HHH and HHH1 are simulating exactly the same thing: the code in the
input including HHH. Here HHH1 succeeds to reach the final halt state,
proving that this final halt states exists, but HHH fails to reach the
same final halt state specified in the input, closes it eyes when it
does a premature abort, and then assumes that what it does not see is
also not in the specification.
That is your logic: Close your eyes and pretend that what is not seen
does not exist.
Open your eyes. HHH and HHH1 have exactly the same input, specifying
exactly the same behaviour according to the x86 language. HHH1 sees the
full specification, but HHH sees only the first part of the
specification and misses the final part, because of a bug hat causes a premature abort. When it would count the conditional branch instructions encountered during the simulation it would be able to see that a finite recursion is not a pattern for non-halting.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: sci.logic

On 7/29/25 11:02 PM, olcott wrote:

On 7/29/2025 8:48 PM, Richard Damon wrote:

On 7/29/25 9:36 PM, olcott wrote:

On 7/29/2025 8:28 PM, Richard Damon wrote:

On 7/29/25 5:34 PM, olcott wrote:

On 7/29/2025 3:37 AM, Fred. Zwarts wrote:

Many times already olcott has claimed to have a proof.
Each time again it turned out that there was no proof.

Op 28.jul.2025 om 18:13 schreef olcott:

<MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>
-a-a-a-a If simulating halt decider H correctly simulates its
-a-a-a-a input D until H correctly determines that its simulated D >>>>>>> -a-a-a-a *would never stop running unless aborted then*

-a-a-a-a H can abort its simulation of D and correctly report that D >>>>>>> -a-a-a-a specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words
10/13/2022>

To make this easier to understand we replace line three
with the more conventional terminology this line:
"cannot possibly reach its own simulated final halt state then"

Which changes the meaning of the sentence, so you can no longer
claim that Sipser agreed to it.

Yes

In addition not-reaching the halt state can have more reasons than >>>>>> a non-halting sequence of instructions. E.g.: a computer being
switched off, a simulation aborted.

This is you not paying close enough attention to the exact
words that I exactly said.

I did not say: DOES NOT REACH ITS FINAL STATE (might have been
aborted)
I said: CANNOT POSSIBLY REACH ITS FINAL STATE (aborted or not)

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

I don't think that is the shell game.-a 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.-a He knows and
accepts that
P(P) actually does stop.-a The wrong answer is justified by what >>>>>>>> would
happen if H (and hence a different P) where not what they
actually are.

Saying that H is required report on the behavior of
machine M is a category error.

Turing machines cannot directly report on the behavior
of other Turing machines they can at best indirectly
report on the behavior of Turing machines through the
proxy of finite string machine descriptions such as rf?Mrf-.

Thus the behavior specified by the input finite string
overrules and supersedes the behavior of the direct
execution.

No, because there is no difference between the specification of
the input and the direct execution.

*I have proven this to be counter-factual*

HHH(DDD) must simulate itself simulating DDD because DDD calls
HHH(DDD)

HHH1(DDD) must NOT simulate itself simulating DDD because DDD DOES
NOT CALL HHH1(DDD)-a-a --- [same behavior as direct execution]

The problem is since you HHH *DOES* abort,

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

void Infinite_Loop()
{
-a-a HERE: goto HERE;
-a-a return;
}

As it always does as soon as it correctly determines
that there exists no N steps of correct simulation
that can possibly reach the "return" instruction final
halt state.

But their is a N number of steps of the correct simulation of DDD that
cause it to halt,

Again you are a fucking liar. You know that halting is
reaching a final halt state and nothing else is halting.
When 0 to infinity steps of DDD are correctly simulated
by HHH no simulated DDD ever halts.

Right, it is *THE PROGRAM* reaching a final state. Dropping that
qualifier is just your standard method of operation.

And more imporantly, non-halting, is THE PROGRAM never reaching a final
state, even after running an unbounded number of steps.

A partial simulation not reaching the final state of the input is NOT non-halting.

And, different input are different and might behave differently,

and programs include ALL the code they use, so DDD includes the code of HHH,

so different HHHs are given different DDDs since they are each built on
the HHH that will try to simulate them.

Sorry, you are just proving you are just a liar who doesn't know what he
is talking about.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: sci.logic

On Tue, 29 Jul 2025 21:48:31 -0400, Richard Damon wrote:

Sorry, you are just showing how stupid and ignorant you are, and that
you don't care that you don't actually know that the words you are using actually mean in this context, which is what makes you the pathological
liar you are.

Yet another ad hominem attack, a logical fallacy!

/Flibble
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: sci.logic

On Wed, 2025-07-30 at 16:55 +0000, Mr Flibble wrote:

On Tue, 29 Jul 2025 21:48:31 -0400, Richard Damon wrote:

Sorry, you are just showing how stupid and ignorant you are, and that
you don't care that you don't actually know that the words you are using actually mean in this context, which is what makes you the pathological liar you are.

Yet another ad hominem attack, a logical fallacy!

/Flibble

If you did not provide logical reason, by your own definition, you 'ad hominem attack'.
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: sci.logic

On 7/30/25 12:55 PM, Mr Flibble wrote:

On Tue, 29 Jul 2025 21:48:31 -0400, Richard Damon wrote:

Sorry, you are just showing how stupid and ignorant you are, and that
you don't care that you don't actually know that the words you are using
actually mean in this context, which is what makes you the pathological
liar you are.

Yet another ad hominem attack, a logical fallacy!

/Flibble

And where did I say he his statement was wrong just because of something
about him?

I showed the error, that you deceitfully trimmed out, showing that you
are just a decietful troll, and thus it is NOT ad hominem, and you prove
your stupidity.
--- Synchronet 3.21a-Linux NewsLink 1.2