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

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

Op 23.aug.2024 om 23:40 schreef olcott:

On 8/23/2024 2:24 AM, joes wrote:

Am Thu, 22 Aug 2024 12:42:59 -0500 schrieb olcott:

Only IF it will in fact keep repeating, which is not the case.

Only IF it *WOULD* in fact keep repeating, *which is the case*
Only IF it *WOULD* in fact keep repeating, *which is the case*
Only IF it *WOULD* in fact keep repeating, *which is the case*
Only IF it *WOULD* in fact keep repeating, *which is the case*

It is the case only if you still cheat with the Root variable, which
makes that HHH processes a non-input, when it is requested to predict
the behaviour of the input.

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

But HHH failed to meet the criteria, since it neither itself does the
required complete simulation or correctly predicts what one will do,
even if we broaden the conditions to allow another simulator to do the test.

The fact is that it *WOULD* in fact keep repeating,
thus *IT DOES* get the correct answer.

No, it doesn't, and the case you poibnt to just doesn't happen without
changing the input, which makes you a cheat.

Remember, DDD it the FULL PROGRAM that was given to HHH to decide on,
which means it includes the code of the HHH that it calls

How does the code for THIS HHH that DOES abort and return ever not abort
and return.

The only way to test that is to give this exact input, which is the code
for the function DDD, still calling that origial HHH that aborts and
retturn to a variant of HHH, like HHH1, that doesn't abort and we see
that this HHH1 does complete the simulation, and thus HHH was wrong, and
that you are nothing but a stupid liar for

The input given to HHH in fact halts, as is seen in the direct
execution and in the correct simulation by HHH1.

The fact is that all deciders only report on the behavior
specified by their inputs and non-inputs are non-of-their-damn
business.

Right, and the input is the DDD that calls THIS HHH, that is the one
that aborts and returns, and not the non-input of a different DDD that
calls that other HHH that doesn't abort.

You break your own rules, and make yourself into a liar, by changing the program that your HHH is looking at.

When HHH computes the mapping from its finite string input
of the x86 machine code of DDD to the the behavior that DDD
specifies HHH correctly predicts that DDD cannot possibly
stop running unless aborted.

But the behavior that HHH computed isn't the behavior of the DDD that it
was given (the DDD that calls this HHH that returns). If a decider on
program bhavior was allowed to be considered correct if it gives an
answer based on its own, possibly incorrect, assumptions about the
program, then add such deciders would be correct, just because they said so.

That's like says a person is correct to the question: "Do you think a
penny is worth more than a dollor?" would be correct to say yes, because
the answer really thought (stupidly) that a penny was worth more than a
dollar.

The halting question is not asking the decider it "It thinks" the input
will halt, (and thus allow bad logic off of partial emulation) but is
asking the factual question, Will the program I am showing your halt
when it is run.

The reason that this seem so strange is not that I am incorrect.
The reason is that everyone rejected simulation as a basis for a
halt decider out-of-hand without review. Because of this they
never saw the details of this behavior when a termination analyzer
correctly emulates an input that calls itself.

Nope, you are incorrect because you are too ignorant to understand what
a decider actually is.

They never notices that there could possibly be a case where
the behavior of the emulation of the machine specified by its
own Machine description (x86 language) could differ from
the direct execution of this same machine.

But it can't be, and you have accepted that fact by failing, MANY TIMES,
to point out which instruction, that was ACTUALLY CORRECT EMULATED,
differed in the simulation from the direct execution.

You, and your HHH, *LIE* by not actually "correctly emulating" the input program, as you don't seem to understand what a "Call" instruction
actually is, in part, because it seems you don't understand what a
PROGRAM actually is

But HHH cannot possibly simulate itself correctly.

The ONLY measure of simulated correctly is that each x86
instruction of N instructions of DDD is emulated correctly and
in the correct order. 2 + 3 = 5 even if you don't believe in numbers.

And thus, the CALL HHH instuction must go into HHH and show what it
actually does.

Since, even when you do follow that path, you see the conditional
instructions in HHH, and thus the "logic" (to use the term lightly) that
you use to decide that DDD is non-halting is just incorrect.

*Simulating Termination Analyzer H is Not Fooled by Pathological Input D* https://www.researchgate.net/publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D

LIES.

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

Op 24.aug.2024 om 15:21 schreef olcott:

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

Op 23.aug.2024 om 23:40 schreef olcott:

On 8/23/2024 2:24 AM, joes wrote:

Am Thu, 22 Aug 2024 12:42:59 -0500 schrieb olcott:

Only IF it will in fact keep repeating, which is not the case.

Only IF it *WOULD* in fact keep repeating, *which is the case*
Only IF it *WOULD* in fact keep repeating, *which is the case*
Only IF it *WOULD* in fact keep repeating, *which is the case*
Only IF it *WOULD* in fact keep repeating, *which is the case*

It is the case only if you still cheat with the Root variable, which
makes that HHH processes a non-input, when it is requested to predict
the behaviour of the input.

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

The fact is that it *WOULD* in fact keep repeating,
thus *IT DOES* get the correct answer.

The fact is that it only happens because you make it so with cheating
with the Root variable.
In the HHH without this cheat, the simulated and the simulating HHH are
coded exactly in the same way to abort after two cycles. Therefore, the
fact is that none of them would keep repeating.
It is just a dream that they would keep repeating. Dreams are no
substitute for facts.

The input given to HHH in fact halts, as is seen in the direct
execution and in the correct simulation by HHH1.

The fact is that all deciders only report on the behavior
specified by their inputs and non-inputs are non-of-their-damn
business.

Exactly. So, they should not predict the behaviour of a hypothetical HHH
that does not abort, but the input, which is a HHH that (when the cheat
is removed) is coded to abort after two cycles.

When HHH computes the mapping from its finite string input
of the x86 machine code of DDD to the the behavior that DDD
specifies HHH correctly predicts that DDD cannot possibly
stop running unless aborted.

And since the HHH is coded to abort, DDD *would* stop running. Dreaming
that the 'unless' does not happen, i.e. dreaming of an HHH that does not
abort, so that DDD does not stop does not help. Dreams are no substitute
for facts.

The reason that this seem so strange is not that I am incorrect.

You are incorrect, but you keep dreaming.

The reason is that everyone rejected simulation as a basis for a
halt decider out-of-hand without review. Because of this they
never saw the details of this behavior when a termination analyzer
correctly emulates an input that calls itself.

The reason that others see that DDD halts, is because they are not
dreaming, but they look at facts: it was proven by the direct execution
and by the correct simulation by HHH1. And they understand what
programming is.

They never notices that there could possibly be a case where
the behavior of the emulation of the machine specified by its
own Machine description (x86 language) could differ from
the direct execution of this same machine.

And they were right, because the *definition* of a correct simulation is
that it agrees with the direct execution.
The only reason why the could differ is an error in the simulator.

But HHH cannot possibly simulate itself correctly.

The ONLY measure of simulated correctly is that each x86
instruction of N instructions of DDD is emulated correctly and
in the correct order.

And without skipping the last (halting) part, and simulating the exact
same instructions as in the direct simulation, starting with exactly the
same initial values of all variables, so no cheating with the Root
variable that differs depending on the level of simulation.

2 + 3 = 5 even if you don't believe in numbers.

And a halting program halts even if you do not believe in halting.

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

On 8/24/24 4:08 PM, olcott wrote:

On 8/24/2024 2:44 PM, Fred. Zwarts wrote:

Op 24.aug.2024 om 15:21 schreef olcott:

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

Op 23.aug.2024 om 23:40 schreef olcott:

On 8/23/2024 2:24 AM, joes wrote:

Am Thu, 22 Aug 2024 12:42:59 -0500 schrieb olcott:

Only IF it will in fact keep repeating, which is not the case.

Only IF it *WOULD* in fact keep repeating, *which is the case*
Only IF it *WOULD* in fact keep repeating, *which is the case*
Only IF it *WOULD* in fact keep repeating, *which is the case*
Only IF it *WOULD* in fact keep repeating, *which is the case*

It is the case only if you still cheat with the Root variable, which
makes that HHH processes a non-input, when it is requested to
predict the behaviour of the input.

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

The fact is that it *WOULD* in fact keep repeating,
thus *IT DOES* get the correct answer.

The fact is that it only happens because you make it so with cheating
with the Root variable.

That THE DECISION IS CORRECT makes moot how the decision was made.
If HHH simply took a wild guess HHH would still be correct.

But it isn't correct, remembr, DDD is a full program (or your a liar)
and includes in its behavior ALL the code that it has, and that code
inlcudes the HHH that does abort and return, thus when HHH hypothosizes
about an HHH that doesn't abort, that HHH is given that exact same DDD,
that calls the HHH that does abort and return, and thus that
Hypothetical HHH will reach the final instruction and thus HHH is not
correct that its Hypothetical HHH will never halt.

Only by "Cheating" and IMPROPERLY changing the input, does HHH reach
that conclusion.

It seems you logic is based on the principle that lies are ok, which
makes it not have an actual definition of truth.

Sorry, you just seems to have a psychological problem with understand
what truth is, making you a pathological liar.

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

On 2024-08-24 20:08:05 +0000, olcott said:

On 8/24/2024 2:44 PM, Fred. Zwarts wrote:

Op 24.aug.2024 om 15:21 schreef olcott:

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

Op 23.aug.2024 om 23:40 schreef olcott:

On 8/23/2024 2:24 AM, joes wrote:

Am Thu, 22 Aug 2024 12:42:59 -0500 schrieb olcott:

Only IF it will in fact keep repeating, which is not the case.

Only IF it *WOULD* in fact keep repeating, *which is the case*
Only IF it *WOULD* in fact keep repeating, *which is the case*
Only IF it *WOULD* in fact keep repeating, *which is the case*
Only IF it *WOULD* in fact keep repeating, *which is the case*

It is the case only if you still cheat with the Root variable, which
makes that HHH processes a non-input, when it is requested to predict
the behaviour of the input.

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

The fact is that it *WOULD* in fact keep repeating,
thus *IT DOES* get the correct answer.

The fact is that it only happens because you make it so with cheating
with the Root variable.

That THE DECISION IS CORRECT makes moot how the decision was made.
If HHH simply took a wild guess HHH would still be correct.

To say "no" about a halting program means that what said "no"
is not a halt decider.

--
Mikko

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

Op 24.aug.2024 om 22:08 schreef olcott:

On 8/24/2024 2:44 PM, Fred. Zwarts wrote:

Op 24.aug.2024 om 15:21 schreef olcott:

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

Op 23.aug.2024 om 23:40 schreef olcott:

On 8/23/2024 2:24 AM, joes wrote:

Am Thu, 22 Aug 2024 12:42:59 -0500 schrieb olcott:

Only IF it will in fact keep repeating, which is not the case.

Only IF it *WOULD* in fact keep repeating, *which is the case*
Only IF it *WOULD* in fact keep repeating, *which is the case*
Only IF it *WOULD* in fact keep repeating, *which is the case*
Only IF it *WOULD* in fact keep repeating, *which is the case*

It is the case only if you still cheat with the Root variable, which
makes that HHH processes a non-input, when it is requested to
predict the behaviour of the input.

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

The fact is that it *WOULD* in fact keep repeating,
thus *IT DOES* get the correct answer.

The fact is that it only happens because you make it so with cheating
with the Root variable.

That THE DECISION IS CORRECT makes moot how the decision was made.
If HHH simply took a wild guess HHH would still be correct.

Your dream is that it the decision is correct. The fact is that the
decision is incorrect. Dreams are no substitute for facts.
As usual an cheating and incorrect method leads to an incorrect result.
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 8/25/24 8:45 AM, olcott wrote:

On 8/25/2024 4:44 AM, Fred. Zwarts wrote:

Op 24.aug.2024 om 22:08 schreef olcott:

On 8/24/2024 2:44 PM, Fred. Zwarts wrote:

Op 24.aug.2024 om 15:21 schreef olcott:

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

Op 23.aug.2024 om 23:40 schreef olcott:

On 8/23/2024 2:24 AM, joes wrote:

Am Thu, 22 Aug 2024 12:42:59 -0500 schrieb olcott:

Only IF it will in fact keep repeating, which is not the case.

Only IF it *WOULD* in fact keep repeating, *which is the case*
Only IF it *WOULD* in fact keep repeating, *which is the case*
Only IF it *WOULD* in fact keep repeating, *which is the case*
Only IF it *WOULD* in fact keep repeating, *which is the case*

It is the case only if you still cheat with the Root variable,
which makes that HHH processes a non-input, when it is requested
to predict the behaviour of the input.

<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> >>>>>
The fact is that it *WOULD* in fact keep repeating,
thus *IT DOES* get the correct answer.

The fact is that it only happens because you make it so with
cheating with the Root variable.

That THE DECISION IS CORRECT makes moot how the decision was made.
If HHH simply took a wild guess HHH would still be correct.

Your dream is that it the decision is correct.

The first part is a tautology. That you fail to understand
that it is a tautology is your failure of understanding and
not my mistake.

No, the first paragraph is not a "tautology" but a condition.

I guess you don't know what a "tautology" means.

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.

The fact is that the decision is incorrect. Dreams are no substitute
for facts.
As usual an cheating and incorrect method leads to an incorrect result.
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)

Op 25.aug.2024 om 14:24 schreef olcott:

On 8/25/2024 2:51 AM, Mikko wrote:

On 2024-08-24 20:08:05 +0000, olcott said:

On 8/24/2024 2:44 PM, Fred. Zwarts wrote:

Op 24.aug.2024 om 15:21 schreef olcott:

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

Op 23.aug.2024 om 23:40 schreef olcott:

On 8/23/2024 2:24 AM, joes wrote:

Am Thu, 22 Aug 2024 12:42:59 -0500 schrieb olcott:

Only IF it will in fact keep repeating, which is not the case.

Only IF it *WOULD* in fact keep repeating, *which is the case*
Only IF it *WOULD* in fact keep repeating, *which is the case*
Only IF it *WOULD* in fact keep repeating, *which is the case*
Only IF it *WOULD* in fact keep repeating, *which is the case*

It is the case only if you still cheat with the Root variable,
which makes that HHH processes a non-input, when it is requested
to predict the behaviour of the input.

<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> >>>>>
The fact is that it *WOULD* in fact keep repeating,
thus *IT DOES* get the correct answer.

The fact is that it only happens because you make it so with
cheating with the Root variable.

That THE DECISION IS CORRECT makes moot how the decision was made.
If HHH simply took a wild guess HHH would still be correct.

To say "no" about a halting program means that what said "no"
is not a halt decider.

<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

No matter how you try to twist those words HHH/DDD do meet that criteria.

(a) When you are hungry you will remain hungry until you eat.

And if you are not hungry, there is no need to eat.

(b) When DDD emulated by HHH is non-halting it will keep running until aborted.

Stop dreaming about a HHH that will keep running, when HHH is coded to
abort and halt. Remove the cheating Root variable and it will easier for
you to understand.
And since HHH is coded to abort after a few cycles, DDD halts and there
is no need to abort. Which is proved by the direct execution and by the simulation by HHH1.
That another HHH (that does not abort and that is given another input of
a HHH that does not abort) does not halt is only confusing, because you
use the same name for it.

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

Op 25.aug.2024 om 21:36 schreef olcott:

On 8/25/2024 12:22 PM, Fred. Zwarts wrote:

Op 25.aug.2024 om 14:24 schreef olcott:

On 8/25/2024 2:51 AM, Mikko wrote:

On 2024-08-24 20:08:05 +0000, olcott said:

On 8/24/2024 2:44 PM, Fred. Zwarts wrote:

Op 24.aug.2024 om 15:21 schreef olcott:

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

Op 23.aug.2024 om 23:40 schreef olcott:

On 8/23/2024 2:24 AM, joes wrote:

Am Thu, 22 Aug 2024 12:42:59 -0500 schrieb olcott:

Only IF it will in fact keep repeating, which is not the case. >>>>>>>>>

Only IF it *WOULD* in fact keep repeating, *which is the case* >>>>>>>>> Only IF it *WOULD* in fact keep repeating, *which is the case* >>>>>>>>> Only IF it *WOULD* in fact keep repeating, *which is the case* >>>>>>>>> Only IF it *WOULD* in fact keep repeating, *which is the case* >>>>>>>

It is the case only if you still cheat with the Root variable, >>>>>>>> which makes that HHH processes a non-input, when it is requested >>>>>>>> to predict the behaviour of the input.

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

The fact is that it *WOULD* in fact keep repeating,
thus *IT DOES* get the correct answer.

The fact is that it only happens because you make it so with
cheating with the Root variable.

That THE DECISION IS CORRECT makes moot how the decision was made.
If HHH simply took a wild guess HHH would still be correct.

To say "no" about a halting program means that what said "no"
is not a halt decider.

<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

No matter how you try to twist those words HHH/DDD do meet that
criteria.

(a) When you are hungry you will remain hungry until you eat.

And if you are not hungry, there is no need to eat.

*If you are hungry and eat THERE WAS A NEED TO EAT*

NOT(If you are hungry and eat THERE WAS NEVER ANY NEED TO EAT)

When HHH is programmed to abort and halt when it thinks it sees an
infinite recursion, the simulated HHH will do the same (unless you still
cheat with the Root variable). And when the simulated HHH was allowed to
reach the point that it thinks that it must abort and halt, it will
return to DDD and DDD will halt. This is shown by the direct execution
and by the correct simulation by HHH1. This proves that HHH aborts too
early when it thinks that there is an infinite recursion.

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

On 8/25/24 3:36 PM, olcott wrote:

On 8/25/2024 12:22 PM, Fred. Zwarts wrote:

Op 25.aug.2024 om 14:24 schreef olcott:

On 8/25/2024 2:51 AM, Mikko wrote:

On 2024-08-24 20:08:05 +0000, olcott said:

On 8/24/2024 2:44 PM, Fred. Zwarts wrote:

Op 24.aug.2024 om 15:21 schreef olcott:

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

Op 23.aug.2024 om 23:40 schreef olcott:

On 8/23/2024 2:24 AM, joes wrote:

Am Thu, 22 Aug 2024 12:42:59 -0500 schrieb olcott:

Only IF it will in fact keep repeating, which is not the case. >>>>>>>>>

Only IF it *WOULD* in fact keep repeating, *which is the case* >>>>>>>>> Only IF it *WOULD* in fact keep repeating, *which is the case* >>>>>>>>> Only IF it *WOULD* in fact keep repeating, *which is the case* >>>>>>>>> Only IF it *WOULD* in fact keep repeating, *which is the case* >>>>>>>

It is the case only if you still cheat with the Root variable, >>>>>>>> which makes that HHH processes a non-input, when it is requested >>>>>>>> to predict the behaviour of the input.

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

The fact is that it *WOULD* in fact keep repeating,
thus *IT DOES* get the correct answer.

The fact is that it only happens because you make it so with
cheating with the Root variable.

That THE DECISION IS CORRECT makes moot how the decision was made.
If HHH simply took a wild guess HHH would still be correct.

To say "no" about a halting program means that what said "no"
is not a halt decider.

<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

No matter how you try to twist those words HHH/DDD do meet that
criteria.

(a) When you are hungry you will remain hungry until you eat.

And if you are not hungry, there is no need to eat.

*If you are hungry and eat THERE WAS A NEED TO EAT*

NOT(If you are hungry and eat THERE WAS NEVER ANY NEED TO EAT)

Which is just a false comparison, as this is talking about transitory
mutable entities with will, verse a deterministic program.

If a program needs to be aborted to halt, then it will ALWAYS need to be aborted to stop, and just because one simulation aborted doesn't change
that fact.

Also, the input condidered needs to be the WHOLE input, and thus the
specific DDD that we are talking about included the specific HHH that it
calls.

Since that, by the problem definition, is the HHH that claims to give
the correct answer, and the deterministic behavior of HHH, means that
since that HHH aborts and returns, then DDD will halt, and thus the
correct emulation of the input doesn't need to be abort, even though HHH
does abort because it THINKS it needs to due to the faulty logic its
programmer gave it.

That DDD calls the HHH that aborts. PERIOD.

And that makes that DDD Halt. PERIOD.

That means that HHH doesn't "need" to abort, but does, and thus is
wrong. PERIOD.

Replacing the code of HHH with an HHH that doesn't abort, changes the
program DDD, and thus none of the above apply, and what this does
doesn't apply to that. PERIOD.

You trying to argue that it does, just proves that you are just ignorant
of the rules of the system you are working in, stupid, and a
pathological liar. PERIOD.

Sorry, those are the facts. Your arguments just prove those statements.

You just don't understand what you are talking about, proven by the fact
that you have been unable to substantiate any of your claims with an
actual scholorly source, because you just don't know of any, because you decided to intentionally work out of ignorance, perhap because you knwo
that to study the field would show you that your ideas couldn't be
correct, and you prefer your ignorant acceptance of your false ideas to
known the truth and that some of your ideas must be wrong.

Sorry, that is the facts. You have made your bed and it seems to put
your reputation 6-feet under the ground.

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