Op 29.aug.2024 om 23:00 schreef olcott:

On 8/29/2024 12:39 PM, Fred. Zwarts wrote:

Op 29.aug.2024 om 15:44 schreef olcott:

On 8/29/2024 2:46 AM, Mikko wrote:

On 2024-08-28 11:51:51 +0000, olcott said:

On 8/28/2024 2:37 AM, Mikko wrote:

This group is for discussions about the theory of computation and
related
topics. Discussion about people is off-topic.

Try to point to the tiniest lack of clarity in this fully
specified concrete example.

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

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

HHH computes the mapping from DDD to behavior that never reaches
its "return" statement on the basis of the x86 emulation of DDD
by HHH according to the semantics of the x86 language.

For all the  years people said that this simulation is incorrect
never realizing that they were disagreeing with the semantics
of the x86 language.

Now that I point this out all that I get for "rebuttal" is bluster
and double talk.

The same thing applies to this more complex example that
is simply over-the-head of most reviewers:

int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

Nice to see that you don't disagree.
But you should not use subject lines that are off-topic for the group. >>>>

When a specific reviewer makes a specific mistake in
reviewing my work related to this group I must refer
to that specific reviewer's mistake to clear my name.

I could generalize it. No one person here besides myself
sufficiently understands the details of how a simulating
halt decider computes the mapping from an input finite
string to the behavior that this finite sting specifies.

It looks more that you are the only person that does not understand
these details, but who thinks that his dreams are a nice substitute
for facts.

I specifically referred to Ben because he got everything
else correctly. Most everyone else cannot even understand
that correct simulation is defined by HHH emulating DDD
according to the semantics of the x86 language.

Olcott does not even understand what the semantics of the x86 language
is. He thinks that a finite string can have different behaviours
according to the semantics of the x86 language, depending on whether
it is directly executed, or simulated by different simulators, where
the semantics could be different for each simulator.

It is well understood in linguistics that the context of an
expression DOES CHANGE THE MEANING OF THE EXPRESSION.

For some languages this is true, but not for the x86 language.
The specification of the semantics of the x86 language nowhere allows a different interpretation depending on the context.

That computer science people are ignorant of these things
makes them incorrect. You cannot correctly ignore context
on the basis that you are unaware that it makes a difference.

That olcott thinks that the x86 language has the same properties as
English, is an error that not even a beginner in computer science would
make.

"This sentence is not true" is not true because
it is not a truth-bearer.

The exact same sentence applied to itself
This sentence is not true: "This sentence is not true" is true.
One level of indirect reference CHANGES EVERYTHING.

Irrelevant counter example.
1) x86 does not have all the properties that English has.
2) There is no self-reference in HHH (when correctly programmed, so, not knowing its own address).
3) There is no extra level of indirection, because there is no
self-reference.

The same thing is occurring with simulating termination
analyzer HHH for input DDD.

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

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


The problem is not in DDD. This is a simpler example.
HHH should process its *input*, not knowing whether that input uses the
same algorithm as used by HHH itself. The code of HHH, when simulated by
HHH, should be considered as a copy of the original code, not as the
code of HHH itself. In fact, the simulated HHH does not need to be an
exact copy of the simulating HHH, it is sufficient that it uses the same algorithm.

That is a fact that olcott ignores, which makes that he gets different
results for the same input depending on whether HHH or HHH1 simulates
the input. His confusion is enhanced because he places the code of the simulated HHH and the simulating HHH in the same memory location. But
that is an artifact that should be ignored. It would help a lot to
remove this confusion when the input for HHH really would be indeed a
finite string containing the whole program, or at least to place the
simulated HHH is a different memory location from the simulating HHH.

The claim that there is a self reference in the question "Does this
input describe a halting program", is equivalent to the claim that the
question "Does this person have blue eyes?" has a self-reference. There
is no self reference, not when the person is your twin brother, not when
you need eyes to see the colour, not even when that person is the same
person as the one that is asked the question.

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

On 8/31/24 9:07 AM, olcott wrote:

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

Op 29.aug.2024 om 23:00 schreef olcott:

On 8/29/2024 12:39 PM, Fred. Zwarts wrote:

Op 29.aug.2024 om 15:44 schreef olcott:

On 8/29/2024 2:46 AM, Mikko wrote:

On 2024-08-28 11:51:51 +0000, olcott said:

On 8/28/2024 2:37 AM, Mikko wrote:

This group is for discussions about the theory of computation
and related
topics. Discussion about people is off-topic.

Try to point to the tiniest lack of clarity in this fully
specified concrete example.

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

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

HHH computes the mapping from DDD to behavior that never reaches >>>>>>> its "return" statement on the basis of the x86 emulation of DDD
by HHH according to the semantics of the x86 language.

For all the  years people said that this simulation is incorrect >>>>>>> never realizing that they were disagreeing with the semantics
of the x86 language.

Now that I point this out all that I get for "rebuttal" is bluster >>>>>>> and double talk.

The same thing applies to this more complex example that
is simply over-the-head of most reviewers:

int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

Nice to see that you don't disagree.
But you should not use subject lines that are off-topic for the
group.

When a specific reviewer makes a specific mistake in
reviewing my work related to this group I must refer
to that specific reviewer's mistake to clear my name.

I could generalize it. No one person here besides myself
sufficiently understands the details of how a simulating
halt decider computes the mapping from an input finite
string to the behavior that this finite sting specifies.

It looks more that you are the only person that does not understand
these details, but who thinks that his dreams are a nice substitute
for facts.

I specifically referred to Ben because he got everything
else correctly. Most everyone else cannot even understand
that correct simulation is defined by HHH emulating DDD
according to the semantics of the x86 language.

Olcott does not even understand what the semantics of the x86
language is. He thinks that a finite string can have different
behaviours according to the semantics of the x86 language, depending
on whether it is directly executed, or simulated by different
simulators, where the semantics could be different for each simulator. >>>>

It is well understood in linguistics that the context of an
expression DOES CHANGE THE MEANING OF THE EXPRESSION.

For some languages this is true, but not for the x86 language.
The specification of the semantics of the x86 language nowhere allows
a different interpretation depending on the context.

For Turing machine deciders it is true:

WST Workshop on Termination, Oxford, 2018 0
Objective and Subjective Specifications
Eric C.R. Hehner
Department of Computer Science, University of Toronto https://www.cs.toronto.edu/~hehner/OSS.pdf

"Can Carol correctly answer “no” to this (yes/no) question?"
This is an incorrect YES/NO question when posed to Carol
because both YES and NO are the wrong answer when posed
to Carol.

Is isomorphic to:
Can a Turing machine decider H return a correct Boolean value
corresponding to the actual behavior of an input D encoded to
do the opposite of whatever value is returned?

Nope, Turing Machines are deterministic entities, "Carol" is a will full
being. And the input to the Turing Machine is a fixed finite string for
which there IS a correct answer.

Note, the question being applied to the Turing Machine is *NOT* that
meta question above (which would be an improper question) but a specific instance of the Halting question, does this input halt when it is run.

That question is valid and objective and has a single correct answer.
The input was just built such that we know that THIS particular decider
will get it wrong.

Being a level off in what you are looking at seems to be a commom
problem for you.

This is an incorrect Boolean question when posed to H because
both TRUE and FALSE are the wrong answer when posed to H.

Nope, there IS a correct answer for every specific Turing Machine H,
just not the one that H gives, as that machine is given a specific input
that represents a specific machine.

We just can use different input to prove diffferent machines wrong, and
can show that we can build such an input for ANY machine that might try
to claim it is correct.

CONTEXT MATTERS EVEN TO TURING MACHINES

Yes, but not here. Remember, in the Turing machine description given to
H, the machine "H" is not named or refered to, only a copy of the code
of H is described. That makes the question OBJECTIVE and not SUBJECTIVE,
and thus not dependent on the "context" of who it is asked to.

The input doesn't change when we give it to a different version of H,
which may well give the correct answer.

Only because you have tried to setup an incorrect "isomorphism" to the
question do you create the subjective nature to the way you try to ask the q

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

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

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

Op 29.aug.2024 om 23:00 schreef olcott:

On 8/29/2024 12:39 PM, Fred. Zwarts wrote:

Op 29.aug.2024 om 15:44 schreef olcott:

On 8/29/2024 2:46 AM, Mikko wrote:

On 2024-08-28 11:51:51 +0000, olcott said:

On 8/28/2024 2:37 AM, Mikko wrote:

This group is for discussions about the theory of computation
and related
topics. Discussion about people is off-topic.

Try to point to the tiniest lack of clarity in this fully
specified concrete example.

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

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

HHH computes the mapping from DDD to behavior that never reaches >>>>>>> its "return" statement on the basis of the x86 emulation of DDD
by HHH according to the semantics of the x86 language.

For all the  years people said that this simulation is incorrect >>>>>>> never realizing that they were disagreeing with the semantics
of the x86 language.

Now that I point this out all that I get for "rebuttal" is bluster >>>>>>> and double talk.

The same thing applies to this more complex example that
is simply over-the-head of most reviewers:

int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

Nice to see that you don't disagree.
But you should not use subject lines that are off-topic for the
group.

When a specific reviewer makes a specific mistake in
reviewing my work related to this group I must refer
to that specific reviewer's mistake to clear my name.

I could generalize it. No one person here besides myself
sufficiently understands the details of how a simulating
halt decider computes the mapping from an input finite
string to the behavior that this finite sting specifies.

It looks more that you are the only person that does not understand
these details, but who thinks that his dreams are a nice substitute
for facts.

I specifically referred to Ben because he got everything
else correctly. Most everyone else cannot even understand
that correct simulation is defined by HHH emulating DDD
according to the semantics of the x86 language.

Olcott does not even understand what the semantics of the x86
language is. He thinks that a finite string can have different
behaviours according to the semantics of the x86 language, depending
on whether it is directly executed, or simulated by different
simulators, where the semantics could be different for each simulator. >>>>

It is well understood in linguistics that the context of an
expression DOES CHANGE THE MEANING OF THE EXPRESSION.

For some languages this is true, but not for the x86 language.
The specification of the semantics of the x86 language nowhere allows
a different interpretation depending on the context.

For Turing machine deciders it is true:

WST Workshop on Termination, Oxford, 2018 0
Objective and Subjective Specifications
Eric C.R. Hehner
Department of Computer Science, University of Toronto https://www.cs.toronto.edu/~hehner/OSS.pdf

"Can Carol correctly answer “no” to this (yes/no) question?"
This is an incorrect YES/NO question when posed to Carol
because both YES and NO are the wrong answer when posed
to Carol.

There is no reason why we can't ask the question to Carol.
If Carol is a machine that can only say "yes", then there is a correct
answer to the question: "no", but Carol cannot give that answer.

Is isomorphic to:
Can a Turing machine decider H return a correct Boolean value
corresponding to the actual behavior of an input D encoded to
do the opposite of whatever value is returned?

Similarly, for the D based on olcott's H there is a correct answer on
the question: "is this a halting program?", namely "yes", but H cannot
give that answer.

This is an incorrect Boolean question when posed to H because
both TRUE and FALSE are the wrong answer when posed to H.

Indeed it has been proved that it is impossible to write a decider that
gives the correct answer for all inputs.

CONTEXT MATTERS EVEN TO TURING MACHINES

It has been shown so many times already that this is incorrect.
It also has been proven that for each input there exists one unique
correct answer on the halting question, independent of whether this
input is process by direct execution of by a simulator.
The semantics of the x86 language allows only one behaviour for the
program described by the finite string.

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

On 8/31/24 12:10 PM, olcott wrote:

On 8/31/2024 10:40 AM, Fred. Zwarts wrote:

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

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

Op 29.aug.2024 om 23:00 schreef olcott:

On 8/29/2024 12:39 PM, Fred. Zwarts wrote:

Op 29.aug.2024 om 15:44 schreef olcott:

On 8/29/2024 2:46 AM, Mikko wrote:

On 2024-08-28 11:51:51 +0000, olcott said:

On 8/28/2024 2:37 AM, Mikko wrote:

This group is for discussions about the theory of computation >>>>>>>>>> and related
topics. Discussion about people is off-topic.

Try to point to the tiniest lack of clarity in this fully
specified concrete example.

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

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

HHH computes the mapping from DDD to behavior that never reaches >>>>>>>>> its "return" statement on the basis of the x86 emulation of DDD >>>>>>>>> by HHH according to the semantics of the x86 language.

For all the  years people said that this simulation is incorrect >>>>>>>>> never realizing that they were disagreeing with the semantics >>>>>>>>> of the x86 language.

Now that I point this out all that I get for "rebuttal" is bluster >>>>>>>>> and double talk.

The same thing applies to this more complex example that
is simply over-the-head of most reviewers:

int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

Nice to see that you don't disagree.
But you should not use subject lines that are off-topic for the >>>>>>>> group.

When a specific reviewer makes a specific mistake in
reviewing my work related to this group I must refer
to that specific reviewer's mistake to clear my name.

I could generalize it. No one person here besides myself
sufficiently understands the details of how a simulating
halt decider computes the mapping from an input finite
string to the behavior that this finite sting specifies.

It looks more that you are the only person that does not
understand these details, but who thinks that his dreams are a
nice substitute for facts.

I specifically referred to Ben because he got everything
else correctly. Most everyone else cannot even understand
that correct simulation is defined by HHH emulating DDD
according to the semantics of the x86 language.

Olcott does not even understand what the semantics of the x86
language is. He thinks that a finite string can have different
behaviours according to the semantics of the x86 language,
depending on whether it is directly executed, or simulated by
different simulators, where the semantics could be different for
each simulator.

It is well understood in linguistics that the context of an
expression DOES CHANGE THE MEANING OF THE EXPRESSION.

For some languages this is true, but not for the x86 language.
The specification of the semantics of the x86 language nowhere
allows a different interpretation depending on the context.

For Turing machine deciders it is true:

WST Workshop on Termination, Oxford, 2018 0
Objective and Subjective Specifications
Eric C.R. Hehner
Department of Computer Science, University of Toronto
https://www.cs.toronto.edu/~hehner/OSS.pdf

"Can Carol correctly answer “no” to this (yes/no) question?"
This is an incorrect YES/NO question when posed to Carol>> because

both YES and NO are the wrong answer when posed

to Carol.

There is no reason why we can't ask the question to Carol.
If Carol is a machine that can only say "yes", then there is a correct
answer to the question: "no", but Carol cannot give that answer.

When posed to Carol both YES and NO are the wrong answer
thus proving that the question is incorrect when the
context of who is asked is not ignored.

But the CONTEXT is that the question was asked to a volitional being.

Your inability to see that seems to indicate that you are somehow not a volitional being anymore, perhaps because you gave your soul to Satan in exchange for the LIE that you could be like God.

Sorry, you are going to be very disappointed when you get to the final judgement and see the real truth.

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

Op 31.aug.2024 om 18:10 schreef olcott:

On 8/31/2024 10:40 AM, Fred. Zwarts wrote:

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

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

Op 29.aug.2024 om 23:00 schreef olcott:

On 8/29/2024 12:39 PM, Fred. Zwarts wrote:

Op 29.aug.2024 om 15:44 schreef olcott:

On 8/29/2024 2:46 AM, Mikko wrote:

On 2024-08-28 11:51:51 +0000, olcott said:

On 8/28/2024 2:37 AM, Mikko wrote:

This group is for discussions about the theory of computation >>>>>>>>>> and related
topics. Discussion about people is off-topic.

Try to point to the tiniest lack of clarity in this fully
specified concrete example.

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

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

HHH computes the mapping from DDD to behavior that never reaches >>>>>>>>> its "return" statement on the basis of the x86 emulation of DDD >>>>>>>>> by HHH according to the semantics of the x86 language.

For all the  years people said that this simulation is incorrect >>>>>>>>> never realizing that they were disagreeing with the semantics >>>>>>>>> of the x86 language.

Now that I point this out all that I get for "rebuttal" is bluster >>>>>>>>> and double talk.

The same thing applies to this more complex example that
is simply over-the-head of most reviewers:

int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

Nice to see that you don't disagree.
But you should not use subject lines that are off-topic for the >>>>>>>> group.

When a specific reviewer makes a specific mistake in
reviewing my work related to this group I must refer
to that specific reviewer's mistake to clear my name.

I could generalize it. No one person here besides myself
sufficiently understands the details of how a simulating
halt decider computes the mapping from an input finite
string to the behavior that this finite sting specifies.

It looks more that you are the only person that does not
understand these details, but who thinks that his dreams are a
nice substitute for facts.

I specifically referred to Ben because he got everything
else correctly. Most everyone else cannot even understand
that correct simulation is defined by HHH emulating DDD
according to the semantics of the x86 language.

Olcott does not even understand what the semantics of the x86
language is. He thinks that a finite string can have different
behaviours according to the semantics of the x86 language,
depending on whether it is directly executed, or simulated by
different simulators, where the semantics could be different for
each simulator.

It is well understood in linguistics that the context of an
expression DOES CHANGE THE MEANING OF THE EXPRESSION.

For some languages this is true, but not for the x86 language.
The specification of the semantics of the x86 language nowhere
allows a different interpretation depending on the context.

For Turing machine deciders it is true:

WST Workshop on Termination, Oxford, 2018 0
Objective and Subjective Specifications
Eric C.R. Hehner
Department of Computer Science, University of Toronto
https://www.cs.toronto.edu/~hehner/OSS.pdf

"Can Carol correctly answer “no” to this (yes/no) question?"
This is an incorrect YES/NO question when posed to Carol>> because

both YES and NO are the wrong answer when posed

to Carol.

There is no reason why we can't ask the question to Carol.
If Carol is a machine that can only say "yes", then there is a correct
answer to the question: "no", but Carol cannot give that answer.

When posed to Carol both YES and NO are the wrong answer
thus proving that the question is incorrect when the
context of who is asked is not ignored.

When Carol is programmed to say 'yes', then 'no' is the correct answer,
but Carol can only respond with the incorrect 'yes'.
Similarly, when HHH is programmed to abort and say 'non-halting', then
the correct answer would be 'halting', but HHH can only respond with the incorrect 'non-halting'.

But I am afraid that it is over your head to see this.

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

On 2024-09-01 10:56:34 +0000, Fred. Zwarts said:

Op 31.aug.2024 om 18:10 schreef olcott:

On 8/31/2024 10:40 AM, Fred. Zwarts wrote:

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

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

Op 29.aug.2024 om 23:00 schreef olcott:

On 8/29/2024 12:39 PM, Fred. Zwarts wrote:

Op 29.aug.2024 om 15:44 schreef olcott:

On 8/29/2024 2:46 AM, Mikko wrote:

On 2024-08-28 11:51:51 +0000, olcott said:

On 8/28/2024 2:37 AM, Mikko wrote:

This group is for discussions about the theory of computation and related
topics. Discussion about people is off-topic.

Try to point to the tiniest lack of clarity in this fully
specified concrete example.

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

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

HHH computes the mapping from DDD to behavior that never reaches >>>>>>>>>> its "return" statement on the basis of the x86 emulation of DDD >>>>>>>>>> by HHH according to the semantics of the x86 language.

For all the  years people said that this simulation is incorrect >>>>>>>>>> never realizing that they were disagreeing with the semantics >>>>>>>>>> of the x86 language.

Now that I point this out all that I get for "rebuttal" is bluster >>>>>>>>>> and double talk.

The same thing applies to this more complex example that
is simply over-the-head of most reviewers:

int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

Nice to see that you don't disagree.
But you should not use subject lines that are off-topic for the group.

When a specific reviewer makes a specific mistake in
reviewing my work related to this group I must refer
to that specific reviewer's mistake to clear my name.

I could generalize it. No one person here besides myself
sufficiently understands the details of how a simulating
halt decider computes the mapping from an input finite
string to the behavior that this finite sting specifies.

It looks more that you are the only person that does not understand >>>>>>> these details, but who thinks that his dreams are a nice substitute for >>>>>>> facts.

I specifically referred to Ben because he got everything
else correctly. Most everyone else cannot even understand
that correct simulation is defined by HHH emulating DDD
according to the semantics of the x86 language.

Olcott does not even understand what the semantics of the x86 language >>>>>>> is. He thinks that a finite string can have different behaviours >>>>>>> according to the semantics of the x86 language, depending on whether it >>>>>>> is directly executed, or simulated by different simulators, where the >>>>>>> semantics could be different for each simulator.

It is well understood in linguistics that the context of an
expression DOES CHANGE THE MEANING OF THE EXPRESSION.

For some languages this is true, but not for the x86 language.
The specification of the semantics of the x86 language nowhere allows a >>>>> different interpretation depending on the context.

For Turing machine deciders it is true:

WST Workshop on Termination, Oxford, 2018 0
Objective and Subjective Specifications
Eric C.R. Hehner
Department of Computer Science, University of Toronto
https://www.cs.toronto.edu/~hehner/OSS.pdf

"Can Carol correctly answer “no” to this (yes/no) question?"
This is an incorrect YES/NO question when posed to Carol>> because

both YES and NO are the wrong answer when posed

to Carol.

There is no reason why we can't ask the question to Carol.
If Carol is a machine that can only say "yes", then there is a correct
answer to the question: "no", but Carol cannot give that answer.

When posed to Carol both YES and NO are the wrong answer
thus proving that the question is incorrect when the
context of who is asked is not ignored.

When Carol is programmed to say 'yes', then 'no' is the correct answer,
but Carol can only respond with the incorrect 'yes'.
Similarly, when HHH is programmed to abort and say 'non-halting', then
the correct answer would be 'halting', but HHH can only respond with
the incorrect 'non-halting'.

But I am afraid that it is over your head to see this.

It doesn't really matter whether what Olcott sees. What matters is that
his readres can see the value of his words.

--
Mikko

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

Op 01.sep.2024 om 13:20 schreef Mikko:

On 2024-09-01 10:56:34 +0000, Fred. Zwarts said:

Op 31.aug.2024 om 18:10 schreef olcott:

On 8/31/2024 10:40 AM, Fred. Zwarts wrote:

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

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

Op 29.aug.2024 om 23:00 schreef olcott:

On 8/29/2024 12:39 PM, Fred. Zwarts wrote:

Op 29.aug.2024 om 15:44 schreef olcott:

On 8/29/2024 2:46 AM, Mikko wrote:

On 2024-08-28 11:51:51 +0000, olcott said:

On 8/28/2024 2:37 AM, Mikko wrote:

This group is for discussions about the theory of
computation and related
topics. Discussion about people is off-topic.

Try to point to the tiniest lack of clarity in this fully >>>>>>>>>>> specified concrete example.

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

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

HHH computes the mapping from DDD to behavior that never reaches >>>>>>>>>>> its "return" statement on the basis of the x86 emulation of DDD >>>>>>>>>>> by HHH according to the semantics of the x86 language.

For all the  years people said that this simulation is incorrect >>>>>>>>>>> never realizing that they were disagreeing with the semantics >>>>>>>>>>> of the x86 language.

Now that I point this out all that I get for "rebuttal" is >>>>>>>>>>> bluster
and double talk.

The same thing applies to this more complex example that >>>>>>>>>>> is simply over-the-head of most reviewers:

int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

Nice to see that you don't disagree.
But you should not use subject lines that are off-topic for >>>>>>>>>> the group.

When a specific reviewer makes a specific mistake in
reviewing my work related to this group I must refer
to that specific reviewer's mistake to clear my name.

I could generalize it. No one person here besides myself
sufficiently understands the details of how a simulating
halt decider computes the mapping from an input finite
string to the behavior that this finite sting specifies.

It looks more that you are the only person that does not
understand these details, but who thinks that his dreams are a >>>>>>>> nice substitute for facts.

I specifically referred to Ben because he got everything
else correctly. Most everyone else cannot even understand
that correct simulation is defined by HHH emulating DDD
according to the semantics of the x86 language.

Olcott does not even understand what the semantics of the x86
language is. He thinks that a finite string can have different >>>>>>>> behaviours according to the semantics of the x86 language,
depending on whether it is directly executed, or simulated by
different simulators, where the semantics could be different for >>>>>>>> each simulator.

It is well understood in linguistics that the context of an
expression DOES CHANGE THE MEANING OF THE EXPRESSION.

For some languages this is true, but not for the x86 language.
The specification of the semantics of the x86 language nowhere
allows a different interpretation depending on the context.

For Turing machine deciders it is true:

WST Workshop on Termination, Oxford, 2018 0
Objective and Subjective Specifications
Eric C.R. Hehner
Department of Computer Science, University of Toronto
https://www.cs.toronto.edu/~hehner/OSS.pdf

"Can Carol correctly answer “no” to this (yes/no) question?"
This is an incorrect YES/NO question when posed to Carol>> because

both YES and NO are the wrong answer when posed

to Carol.

There is no reason why we can't ask the question to Carol.
If Carol is a machine that can only say "yes", then there is a
correct answer to the question: "no", but Carol cannot give that
answer.

When posed to Carol both YES and NO are the wrong answer
thus proving that the question is incorrect when the
context of who is asked is not ignored.

When Carol is programmed to say 'yes', then 'no' is the correct
answer, but Carol can only respond with the incorrect 'yes'.
Similarly, when HHH is programmed to abort and say 'non-halting', then
the correct answer would be 'halting', but HHH can only respond with
the incorrect 'non-halting'.

But I am afraid that it is over your head to see this.

It doesn't really matter whether what Olcott sees. What matters is that
his readres can see the value of his words.

I guess you are right. There is probably no reason for hope left that
Olcott will learn, but others may learn from his errors.
Thanks for the thought.

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

On 9/2/24 9:13 AM, olcott wrote:

On 9/1/2024 6:20 AM, Mikko wrote:

On 2024-09-01 10:56:34 +0000, Fred. Zwarts said:

Op 31.aug.2024 om 18:10 schreef olcott:

On 8/31/2024 10:40 AM, Fred. Zwarts wrote:

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

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

Op 29.aug.2024 om 23:00 schreef olcott:

On 8/29/2024 12:39 PM, Fred. Zwarts wrote:

Op 29.aug.2024 om 15:44 schreef olcott:

On 8/29/2024 2:46 AM, Mikko wrote:

On 2024-08-28 11:51:51 +0000, olcott said:

On 8/28/2024 2:37 AM, Mikko wrote:

This group is for discussions about the theory of
computation and related
topics. Discussion about people is off-topic.

Try to point to the tiniest lack of clarity in this fully >>>>>>>>>>>> specified concrete example.

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

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

HHH computes the mapping from DDD to behavior that never >>>>>>>>>>>> reaches
its "return" statement on the basis of the x86 emulation of DDD >>>>>>>>>>>> by HHH according to the semantics of the x86 language. >>>>>>>>>>>>
For all the  years people said that this simulation is >>>>>>>>>>>> incorrect
never realizing that they were disagreeing with the semantics >>>>>>>>>>>> of the x86 language.

Now that I point this out all that I get for "rebuttal" is >>>>>>>>>>>> bluster
and double talk.

The same thing applies to this more complex example that >>>>>>>>>>>> is simply over-the-head of most reviewers:

int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

Nice to see that you don't disagree.
But you should not use subject lines that are off-topic for >>>>>>>>>>> the group.

When a specific reviewer makes a specific mistake in
reviewing my work related to this group I must refer
to that specific reviewer's mistake to clear my name.

I could generalize it. No one person here besides myself
sufficiently understands the details of how a simulating
halt decider computes the mapping from an input finite
string to the behavior that this finite sting specifies.

It looks more that you are the only person that does not
understand these details, but who thinks that his dreams are a >>>>>>>>> nice substitute for facts.

I specifically referred to Ben because he got everything
else correctly. Most everyone else cannot even understand
that correct simulation is defined by HHH emulating DDD
according to the semantics of the x86 language.

Olcott does not even understand what the semantics of the x86 >>>>>>>>> language is. He thinks that a finite string can have different >>>>>>>>> behaviours according to the semantics of the x86 language,
depending on whether it is directly executed, or simulated by >>>>>>>>> different simulators, where the semantics could be different >>>>>>>>> for each simulator.

It is well understood in linguistics that the context of an
expression DOES CHANGE THE MEANING OF THE EXPRESSION.

For some languages this is true, but not for the x86 language.
The specification of the semantics of the x86 language nowhere
allows a different interpretation depending on the context.

For Turing machine deciders it is true:

WST Workshop on Termination, Oxford, 2018 0
Objective and Subjective Specifications
Eric C.R. Hehner
Department of Computer Science, University of Toronto
https://www.cs.toronto.edu/~hehner/OSS.pdf

"Can Carol correctly answer “no” to this (yes/no) question?"
This is an incorrect YES/NO question when posed to Carol>> because

both YES and NO are the wrong answer when posed

to Carol.

There is no reason why we can't ask the question to Carol.
If Carol is a machine that can only say "yes", then there is a
correct answer to the question: "no", but Carol cannot give that
answer.

When posed to Carol both YES and NO are the wrong answer
thus proving that the question is incorrect when the
context of who is asked is not ignored.

When Carol is programmed to say 'yes', then 'no' is the correct
answer, but Carol can only respond with the incorrect 'yes'.
Similarly, when HHH is programmed to abort and say 'non-halting',
then the correct answer would be 'halting', but HHH can only respond
with the incorrect 'non-halting'.

But I am afraid that it is over your head to see this.

It doesn't really matter whether what Olcott sees. What matters is that
his readres can see the value of his words.

The link to the PhD computer science professor that agrees with me.

Which just proves you aren't the only idiot with this idea.

In fact, most of what you have said sounds like stuff I have heard
before, so you aren't even really original in your thoughts. (Not saying
you have intentionally copied the ideas)

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