Am Sat, 24 Aug 2024 08:21:45 -0500 schrieb 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*

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.

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

The simulated, aborting HHH would… abort.

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.

Non-inputs such as a pure simulator that does not abort.

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.

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

Yes it is.

The reason is that everyone rejected simulation as a basis for a halt
decider out-of-hand without review.

Absolutely not. What do you think we are doing here?

Because of this they never saw the
details of this behavior when a termination analyzer correctly emulates
an input that calls itself.

The details have been sufficiently dissected.

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.

Which means the simulator is wrong.

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.

ALL instructions.

--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.

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

Op 24.aug.2024 om 16:35 schreef olcott:

On 8/24/2024 9:27 AM, joes wrote:

Am Sat, 24 Aug 2024 08:21:45 -0500 schrieb 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*

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.

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

The simulated, aborting HHH would… abort.

<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

Why repeating this over and over again if you do not understand the words? Sipser agreed to 'If ... correctly simulates ... correctly determines ...'. There is no correct simulation, there is no correct determination, so
the remainder of the sentence does not apply.
Maybe you should read it a few more times, until you understand what
'if' means.
Maybe use a dictionary to learn the meaning of English words.

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

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

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

Op 24.aug.2024 om 16:35 schreef olcott:

On 8/24/2024 9:27 AM, joes wrote:

Am Sat, 24 Aug 2024 08:21:45 -0500 schrieb 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*

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.

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

The simulated, aborting HHH would… abort.

<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

Why repeating this over and over again if you do not understand the
words?
Sipser agreed to 'If ... correctly simulates ...

Meaning: Emulates the input finite string according
to the semantics of the x86 language.

But it the finite string doesn't contain ALL of the code needed to eb emulatied, which means ALL the code use by DDD, which includes the code
of HHH it can't actually be done.

So, since you START with an error in your definition, since you try to
define "DDD" as JUST the code of the "C function" DDD, and not the
PROGRAM DDD, you begin with the LIE of a CATEGORY ERROR.

I have corrected you too many times on this to believe
that you are honest.

No, you have repeated your ERROR too many times to believe that it is
just an honest error. You have proved yourself to be a pathological liar.

correctly determines ...'.

If DDD WOULD never stop running when emulated by
a hypothetical HHH that never aborts then this

But the PROGRAM DDD, which calls the original HHH as the description of
the proper program does, DOES reach a final state,

would never stop running unless aborted
would never stop running unless aborted
would never stop running unless aborted

But it does. Only in your LIES does it not.

Sorry, your repeating the errors and not addressing them just proves
that you are a stupid ignorant pathological liar.

Thus, even if you do try to properly derive your new "correct reasoning"
logic system, many people will just not even look at it, because why
should they trust anything from a person with that repuration.

Sorry, you are must killing you ability to be believed about anything.

There is no correct simulation, there is no correct determination, so
the remainder of the sentence does not apply.
Maybe you should read it a few more times, until you understand what
'if' means.
Maybe use a dictionary to learn the meaning of English words.

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

On 2024-08-24 19:49:42 +0000, Fred. Zwarts said:

Op 24.aug.2024 om 16:35 schreef olcott:

On 8/24/2024 9:27 AM, joes wrote:

Am Sat, 24 Aug 2024 08:21:45 -0500 schrieb 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*

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.

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

The simulated, aborting HHH would… abort.

<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

Why repeating this over and over again if you do not understand the words? Sipser agreed to 'If ... correctly simulates ... correctly determines ...'. There is no correct simulation, there is no correct determination, so
the remainder of the sentence does not apply.
Maybe you should read it a few more times, until you understand what
'if' means.
Maybe use a dictionary to learn the meaning of English words.

For certain words like "if" and "would" a grammar book might be better.

--
Mikko

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

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

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

Op 24.aug.2024 om 16:35 schreef olcott:

On 8/24/2024 9:27 AM, joes wrote:

Am Sat, 24 Aug 2024 08:21:45 -0500 schrieb 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*

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.

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

The simulated, aborting HHH would… abort.

<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

Why repeating this over and over again if you do not understand the
words?
Sipser agreed to 'If ... correctly simulates ...

Meaning: Emulates the input finite string according
to the semantics of the x86 language.

I have corrected you too many times on this to believe
that you are honest.

Why don't you listen to corrections? The simulation violates the
semantics of the x86 language by skipping the last cycle of the
simulated halting program.
It further violates the semantics of the x86 language by changing the
value of the cheating Root variable when there is no instruction to do
so in the simulation.

Repeat this a few times until you understand it: violates the semantics
of the x86 language by arbitrarily changing values of variables and by
skipping the last cycle of the simulated halting program.

correctly determines ...'.

If DDD WOULD never stop running when emulated by
a hypothetical HHH that never aborts then this is

Another thing to repeat: HHH must process its input, not a hypothetical non-input.
Is that so difficult to understand?
The input to be simulated is the HHH that must behave exactly as the
simulating HHH: abort and halt.
No cheating with a Root variable to justify that incorrect results are
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 8/25/24 8:32 AM, olcott wrote:

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

On 2024-08-24 19:49:42 +0000, Fred. Zwarts said:

Op 24.aug.2024 om 16:35 schreef olcott:

On 8/24/2024 9:27 AM, joes wrote:

Am Sat, 24 Aug 2024 08:21:45 -0500 schrieb 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*

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.

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

The simulated, aborting HHH would… abort.

<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

Why repeating this over and over again if you do not understand the
words?
Sipser agreed to 'If ... correctly simulates ... correctly determines
...'.
There is no correct simulation, there is no correct determination, so
the remainder of the sentence does not apply.
Maybe you should read it a few more times, until you understand what
'if' means.
Maybe use a dictionary to learn the meaning of English words.

For certain words like "if" and "would" a grammar book might be better.

"IF" AKA within the following assumed premises:
  {HHH emulates N instructions of DDD according to the
   semantics of the x86 language}

"UNTIL" (this condition is met)
{a preexisting correct non-halting behavior
 pattern has been matched by these N instructions}

But it doesn't present "correct non-halting behavior patteren" since
that exact same pattern can produce a halting simulation.

To correctly determine something, it can't be false.

And since HHH is the code that it is, if it will abort, that possiblity
will show up in the simulation, so it must take that into account, or it
isn't properly simulating those instructions.

Remebmer HHH1 simulated that EXACT SAME input, and will see the exact
same first N instructions (at least if HHH is a pure function) and thus
the fact that HHH1 reaches a final state in its simulation PROVES that
it isn't a "non-halting pattern"

Sorry, you are just working under the burden of having false premises
filling your thought process. When your logic system has LIES as some of
its premsises, it doesn't give the right answers.

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

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

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

On 2024-08-24 19:49:42 +0000, Fred. Zwarts said:

Op 24.aug.2024 om 16:35 schreef olcott:

On 8/24/2024 9:27 AM, joes wrote:

Am Sat, 24 Aug 2024 08:21:45 -0500 schrieb 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*

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.

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

The simulated, aborting HHH would… abort.

<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

Why repeating this over and over again if you do not understand the
words?
Sipser agreed to 'If ... correctly simulates ... correctly
determines ...'.
There is no correct simulation, there is no correct determination, so
the remainder of the sentence does not apply.
Maybe you should read it a few more times, until you understand what
'if' means.
Maybe use a dictionary to learn the meaning of English words.

For certain words like "if" and "would" a grammar book might be better.

"IF" AKA within the following assumed premises:
  {HHH emulates N instructions of DDD according to the
   semantics of the x86 language}

But it skipped the last few instructions which would show that the input
would abort and halt. Therefore it missed the fact that there was no
infinite repetition.

"UNTIL" (this condition is met)
{a preexisting correct non-halting behavior
 pattern has been matched by these N instructions}

And this did not happen. The non-halting pattern was not present,
because HHH is coded to halt after a few cycles. So, the condition was incorrectly determined. Sipser would agree.

Since Sipser agreed only IF the simulation would be correct (which it
isn't) UNTIL the condition would be met (which isn't), we can forget the remainder.

Sipser agreement does not *prove* that the simulation is correct, or
that the condition is correct, but it *assumes* that the simulation is
correct and that the condition is met.
Your task is now to prove that these assumptions are true. Only then
Sipser's agreement makes any sense.

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