On 8/19/23 10:34 AM, olcott wrote:
> On 8/19/2023 3:38 AM, Mikko wrote:
>> On 2023-08-18 17:07:09 +0000, olcott said:
>>
>>> On 8/18/2023 11:54 AM, Mikko wrote:
>>>> On 2023-08-18 14:18:55 +0000, olcott said:
>>>>
>>>>> *Thus you agree with this*
>>>>> D correctly simulated by H cannot possibly reach past its own line 06.
>>>>
>>>> I'm mot sure it is correct English to use "D" as a subject to an active
>>>> verb "reach" as D is not present and therefore cannot actively do
>>>> anything.
>>>> Anyway, one can say that H cannot correctly simulate D(D) past line 6,
>>>> which apparently is what you try to express with that sentence.
>>>>
>>>> Mikko
>>>>
>>>
>>> It is not an error of H that prevents the correct simulation of G past
>>> line 06, it is the pathological relationship that D defines with H that
>>> makes this impossible.
>>
>> If H(D,D) says "does not halt" but D(D) halts then H is not a halt
>> decider
>
> If Bill's identical twin brother robs a liquor store and Mary said that
> Bill did it Mary is wrong. The instance of D that H determines does not
> halt is a different instance than the one that halts.
>
> The one that halts only halts because the other different one has been
> aborted.

No, D(D) Halts because it Halts. The thing that causes it to halt it
part of it (the code for the H it calls is part of the code for the
PROGRAM D).

Remember, Halting is about the behavior of that ACTUAL MACHINE, not some
partial simulation of it.

>
>> because it does not satisfy the definition of "halt decider".
>
> Every halt decider must map its actual input to its own accept or reject
> state on the basis of the actual behavior of this actual input and is
> not allowed to report on the differing behavior of any non-input such as
> D(D) directly executed in main().

IF H doesn't answer the question required to be answered by a Halt
Decider, it isn't a Halt Decider. PERIOD.

It isn't even a "twin brother" to a Halt Decider.

The question a Halt Decider MUST be answering to be a Halt Decider is
does the ACTUAL MACHINE REPRESENTED by the input Halt when run.

Since D(D) Halts when run, and you admit that (and it doesn't matter WHY
it does, just that it does), the ONLY correct answer for a Halt Decider
when given its representation of that machine is to answer Halting.

Since you claim D is built exactly by the definition of the proof, and D
is defined to ask its copy of H what is the behavior of D applied to its
input, and D(p) calls H(p,p) this means that D(D) calling H(D,D) MUST be
asking about the behavior of the program D(D).

Thus, the behaviof of D(D) IS the "behavior of the input" or you have
defined somethig incorrectly, and are just lying.

>
> You admitted that the input to H(D,D) cannot possibly terminate
> normally. This proves that it is correctly determined to be non-halting.

No, it is admitted that no H can possible simulate the input D based on
it to a terminal state.

THIS H, the one that answers, fails because it gives up. That does NOT
mean that an ACTUAL Correct simulation of the input to H will not reach
a final state.

>
>> Whether that is an error depends on whether H is claimed or required
>> to be
>> a halt decider.
>>
>> Mikko
>>
>

You are just proving that you just don't understand the words you are
using and are just a pathological liar.

On 8/19/2023 3:38 AM, Mikko wrote:
> On 2023-08-18 17:07:09 +0000, olcott said:
>
>> On 8/18/2023 11:54 AM, Mikko wrote:
>>> On 2023-08-18 14:18:55 +0000, olcott said:
>>>
>>>> *Thus you agree with this*
>>>> D correctly simulated by H cannot possibly reach past its own line 06.
>>>
>>> I'm mot sure it is correct English to use "D" as a subject to an active
>>> verb "reach" as D is not present and therefore cannot actively do
>>> anything.
>>> Anyway, one can say that H cannot correctly simulate D(D) past line 6,
>>> which apparently is what you try to express with that sentence.
>>>
>>> Mikko
>>>
>>
>> It is not an error of H that prevents the correct simulation of G past
>> line 06, it is the pathological relationship that D defines with H that
>> makes this impossible.
>
> If H(D,D) says "does not halt" but D(D) halts then H is not a halt decider
> because it does not satisfy the definition of "halt decider".

If D correctly simulated by H cannot possibly terminate normally then
this proves that the actual behavior of the actual input is non-halting.

A halt decider is required to report on the actual behavior of the
actual input and it not allowed to report on any other behavior.

> Whether that is an error depends on whether H is claimed or required to be
> a halt decider.
>
> Mikko
>

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

On 8/19/23 7:02 PM, olcott wrote:
> On 8/19/2023 3:38 AM, Mikko wrote:
>> On 2023-08-18 17:07:09 +0000, olcott said:
>>
>>> On 8/18/2023 11:54 AM, Mikko wrote:
>>>> On 2023-08-18 14:18:55 +0000, olcott said:
>>>>
>>>>> *Thus you agree with this*
>>>>> D correctly simulated by H cannot possibly reach past its own line 06.
>>>>
>>>> I'm mot sure it is correct English to use "D" as a subject to an active
>>>> verb "reach" as D is not present and therefore cannot actively do
>>>> anything.
>>>> Anyway, one can say that H cannot correctly simulate D(D) past line 6,
>>>> which apparently is what you try to express with that sentence.
>>>>
>>>> Mikko
>>>>
>>>
>>> It is not an error of H that prevents the correct simulation of G past
>>> line 06, it is the pathological relationship that D defines with H that
>>> makes this impossible.
>>
>> If H(D,D) says "does not halt" but D(D) halts then H is not a halt
>> decider
>> because it does not satisfy the definition of "halt decider".
>
> If D correctly simulated by H cannot possibly terminate normally then
> this proves that the actual behavior of the actual input is non-halting.

Only if you show that H DOES correctly simulate its input. And that
means it simulates it to the end, which means that it can't answer.

So, no, your statement is a contradiction.

>
> A halt decider is required to report on the actual behavior of the
> actual input and it not allowed to report on any other behavior.

And the only "Actual Behavior" that matters is the behavior of the
machine represented by the input, which will match that actual correct
(and thus unaborted) simulation of that input.

Since H doesn't even claim to do that, it is just not a Halt Decider,
and you are proven to be a LIAR.

You are just showing you don't understand what you are talking about,
and too stupid to learn the meaning when it is explained to you.

That, or just a pathological liar.

>
>> Whether that is an error depends on whether H is claimed or required
>> to be
>> a halt decider.
>>
>> Mikko
>>
>

Fundamentally, your problem is rooted in an incorrect understanding of
what truth actually is, A question which it is impossible for a
computation to answer is not wrong, just not computable.

THis is actaully expected as there are only a countable infinite number
of possible deciders, but an uncountable number of problems to decide
on, so virtually all problems are not computable.

Yes, there are a number of interesting problems that are computable, but
also a number that are not.

There is nothing wrong with this fact.

This is also leads to the fact that some statements are true but not
provable in any system that is advanced enough.

It seems you can only understand systems too simple for this to happen,
and it seems you can't understand system that lead to uncountable infinitis.

On 2023-08-18 17:08:52 +0000, olcott said:

> On 8/18/2023 12:03 PM, Mikko wrote:
>> On 2023-08-18 15:48:09 +0000, olcott said:
>>
>>> The behavior of D(D) directly executed in main() does *NOT*
>>> provide the behavior of the actual input to H(D,D).
>>
>> Of course not. The actual input to H(D,D) is just a text string
>> that has no behaviour. It can be interpreted to specify a behaviour
>> but it iself does not behave.
>>
>> The actual behaviour of D(D) is merely a reference for determination
>> of the orrectness of the answer given by H(D,D).
>>
>> Mikko
>>
>
> The notion of a UTM proves that D correctly simulated by H does provide
> the behavior that H must report on.

A notion does not prove anything. Your main claims are unproven util you
prove them.

Mikko

On 2023-08-19 14:34:49 +0000, olcott said:

> If Bill's identical twin brother robs a liquor store and Mary said that
> Bill did it Mary is wrong. The instance of D that H determines does not
> halt is a different instance than the one that halts.

That's a good analogy;
Bill <-> D
Biss's identical twin <-> simulation of D
Mary <-> H
robs a liquoar store <-> fails to halt
is wrong <-> is wrong

> You admitted that the input to H(D,D) cannot possibly terminate
> normally. This proves that it is correctly determined to be non-halting.

Yes. It is a gategoy error to even ask whether it can. Input is text
and text does not halt or fail to halt. The requirement is that H
tells whether the input is a decription of a halting or non-halting
computation.

Mikko

On 2023-08-19 23:02:11 +0000, olcott said:

> If D correctly simulated by H cannot possibly terminate normally then
> this proves that the actual behavior of the actual input is non-halting.

D correctly simulated by H does not even exist unless H correctly simulates
D. However, there is not need to say anything about "D correctly simulated
by H" because pain "D" is sufficient.

H's simulation of D is another thing. It is not the same as D although
there is some similarity if H simulates correctly.

> A halt decider is required to report on the actual behavior of the
> actual input and it not allowed to report on any other behavior.

A decider is required to tell whether a text is of the kind that
the decider is required to identify. For a halt decider the requirement
is that the text is a description of a halting computation.

Mikko

On 8/18/23 1:08 PM, olcott wrote:
>
> The notion of a UTM proves that D correctly simulated by H does provide
> the behavior that H must report on.
>

"THe notion of a UTM" says that the "Correct Simulation" of an input
that represents a computation is one the produces the exact same results
as that computation.

Since D(D) Halts, the only correct simulation, BY DEFINITION, says its
halts, and runs until it shows that.

Since H aborts its simulation becuase of something it "believes", it
doesn't actually do a correct simulation, thus its logic can't be based
on it actually doing a correct simulation, which is why its belief is
just incorrect.

All you are doing is proving that you don't understand what you are
talking about but just spewing word salad.

You looking at "any H" means you are looking at DIFFERENT Hs, not the H
given, and looking at different Ds.

So, to quote your own words from the past, since you are looking at an
input other than the one actually given (which is based on THIS H, not
some other one) you are just a pathetic liar. BY YOUR OWN DEFINITION.

You are just so stupid, you don't understand the meaning of some very
basic words, like "program" or "Correct" or even "True".

On 8/20/2023 3:10 AM, Mikko wrote:
> On 2023-08-18 17:08:52 +0000, olcott said:
>
>> On 8/18/2023 12:03 PM, Mikko wrote:
>>> On 2023-08-18 15:48:09 +0000, olcott said:
>>>
>>>> The behavior of D(D) directly executed in main() does *NOT*
>>>> provide the behavior of the actual input to H(D,D).
>>>
>>> Of course not. The actual input to H(D,D) is just a text string
>>> that has no behaviour. It can be interpreted to specify a behaviour
>>> but it iself does not behave.
>>>
>>> The actual behaviour of D(D) is merely a reference for determination
>>> of the orrectness of the answer given by H(D,D).
>>>
>>> Mikko
>>>
>>
>> The notion of a UTM proves that D correctly simulated by H does provide
>> the behavior that H must report on.
>
> A notion does not prove anything. Your main claims are unproven util you
> prove them.
>
> Mikko
>

The notion of a UTM stipulates that D correctly simulated by H does
provide the actual behavior of the input to H(D,D).

The source-code of D and H stipulates that a correct simulation of D
by H must include the pathological relationship that D defines with H.

// The following is written in C
//
01 typedef int (*ptr)(); // pointer to int function
02 int H(ptr x, ptr y) // uses x86 emulator to simulate its input
03
04 int D(ptr x)
05 {
06 int Halt_Status = H(x, x);
07 if (Halt_Status)
08 HERE: goto HERE;
09 return Halt_Status;
10 }
11
12 void main()
13 {
14 H(D,D);
15 }

Anyone that says D simulated by H can possibly terminate normally
is either an ignoramus or a liar.

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

On 8/20/2023 3:25 AM, Mikko wrote:
> On 2023-08-19 14:34:49 +0000, olcott said:
>
>> If Bill's identical twin brother robs a liquor store and Mary said that
>> Bill did it Mary is wrong. The instance of D that H determines does not
>> halt is a different instance than the one that halts.
>
> That's a good analogy;
> Bill <-> D
> Biss's identical twin <-> simulation of D
> Mary <-> H
> robs a liquoar store <-> fails to halt
> is wrong <-> is wrong
>
>> You admitted that the input to H(D,D) cannot possibly terminate
>> normally. This proves that it is correctly determined to be non-halting.
>
> Yes. It is a gategoy error to even ask whether it can.

Not at all the execution trace of D correctly simulated by H
simply proves that D gets stuck at its own line 06.

// The following is written in C
//
01 typedef int (*ptr)(); // pointer to int function
02 int H(ptr x, ptr y) // uses x86 emulator to simulate its input
03
04 int D(ptr x)
05 {
06 int Halt_Status = H(x, x);
07 if (Halt_Status)
08 HERE: goto HERE;
09 return Halt_Status;
10 }
11
12 void main()
13 {
14 H(D,D);
15 }

It would be a category error if we asked:
Does D correctly simulated by H really want a large glass of cold milk?

> Input is text

and D correctly simulated by H provides the behavior actually specified
by this text.

> and text does not halt or fail to halt. The requirement is that H
> tells whether the input is a decription of a halting or non-halting
> computation.
>
> Mikko
>

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

On 8/20/2023 3:32 AM, Mikko wrote:
> On 2023-08-19 23:02:11 +0000, olcott said:
>
>> If D correctly simulated by H cannot possibly terminate normally then
>> this proves that the actual behavior of the actual input is non-halting.
>
> D correctly simulated by H does not even exist unless H correctly simulates
> D. However, there is not need to say anything about "D correctly simulated
> by H" because pain "D" is sufficient.
>
> H's simulation of D is another thing. It is not the same as D although
> there is some similarity if H simulates correctly.
>
>> A halt decider is required to report on the actual behavior of the
>> actual input and it not allowed to report on any other behavior.
>
> A decider is required to tell whether a text is of the kind that
> the decider is required to identify. For a halt decider the requirement
> is that the text is a description of a halting computation.
>
> Mikko
>

https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X

*Thu 10/13/2022 11:29 AM email from*
MIT Professor Michael Sipser has agreed that the following verbatim
words are correct (he has not agreed to anything else):

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.

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

On 8/20/23 11:56 AM, olcott wrote:
> On 8/20/2023 3:10 AM, Mikko wrote:
>> On 2023-08-18 17:08:52 +0000, olcott said:
>>
>>> On 8/18/2023 12:03 PM, Mikko wrote:
>>>> On 2023-08-18 15:48:09 +0000, olcott said:
>>>>
>>>>> The behavior of D(D) directly executed in main() does *NOT*
>>>>> provide the behavior of the actual input to H(D,D).
>>>>
>>>> Of course not. The actual input to H(D,D) is just a text string
>>>> that has no behaviour. It can be interpreted to specify a behaviour
>>>> but it iself does not behave.
>>>>
>>>> The actual behaviour of D(D) is merely a reference for determination
>>>> of the orrectness of the answer given by H(D,D).
>>>>
>>>> Mikko
>>>>
>>>
>>> The notion of a UTM proves that D correctly simulated by H does provide
>>> the behavior that H must report on.
>>
>> A notion does not prove anything. Your main claims are unproven util you
>> prove them.
>>
>> Mikko
>>
>
> The notion of a UTM stipulates that D correctly simulated by H does
> provide the actual behavior of the input to H(D,D).

Right, and the key point here is the term *CORRECTLY* which means, BY
DEFINITION OF A UTM, a simulation that EXACTLY produces the same
behavior as the direct execution of the machine.

>
> The source-code of D and H stipulates that a correct simulation of D
> by H must include the pathological relationship that D defines with H.

Right, D calls the H that is claimed to be giving the right answer, and
thus, what ever simulator being used, even H, must take the behavior of
THIS H into account. Since this H aborts its simulation and returns 0,
then the simulator must conclude the same thing.

THe "Pathology" means that this is IMPOSSIBLE for H to do, the H can not
"Correctly Simulate" the input (at least this one doesn't, and no
variation that gives an answer can).

>
> // The following is written in C
> //
> 01 typedef int (*ptr)(); // pointer to int function
> 02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
> 03
> 04 int D(ptr x)
> 05 {
> 06   int Halt_Status = H(x, x);
> 07   if (Halt_Status)
> 08     HERE: goto HERE;
> 09   return Halt_Status;
> 10 }
> 11
> 12 void main()
> 13 {
> 14   H(D,D);
> 15 }
>
> Anyone that says D simulated by H can possibly terminate normally
> is either an ignoramus or a liar.
>

Whose says that D simulated by H can possible terminte normally.

The claim is that a CORRECT SIMULTION of the input to H will. The fact
that H doesn't (and can't) do that is the heart of your problem.

You just don't understand what "Correct" means, because you don't
undertand the fundamental nature of truth.

On 8/20/23 12:00 PM, olcott wrote:
> On 8/20/2023 3:25 AM, Mikko wrote:
>> On 2023-08-19 14:34:49 +0000, olcott said:
>>
>>> If Bill's identical twin brother robs a liquor store and Mary said that
>>> Bill did it Mary is wrong. The instance of D that H determines does not
>>> halt is a different instance than the one that halts.
>>
>> That's a good analogy;
>> Bill <-> D
>> Biss's identical twin <-> simulation of D
>> Mary <-> H
>> robs a liquoar store <-> fails to halt
>> is wrong <-> is wrong
>>
>>> You admitted that the input to H(D,D) cannot possibly terminate
>>> normally. This proves that it is correctly determined to be non-halting.
>>
>> Yes. It is a gategoy error to even ask whether it can.
>
> Not at all the execution trace of D correctly simulated by H
> simply proves that D gets stuck at its own line 06.

How is that possible for a CORRECT simulation?

line 6 says D calls H with parameters of D and D.

Thus a CORRECT simulation of that instruction says the next thing seen
should be the first instruction of the copy of H that D contains.

You do understand the "Program D" includes ALL of the code that it uses,
so it includes the code of the H that it calls.

If H can't simulate that, then it is the fault of H, not D.

>
> // The following is written in C
> //
> 01 typedef int (*ptr)(); // pointer to int function
> 02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
> 03
> 04 int D(ptr x)
> 05 {
> 06   int Halt_Status = H(x, x);
> 07   if (Halt_Status)
> 08     HERE: goto HERE;
> 09   return Halt_Status;
> 10 }
> 11
> 12 void main()
> 13 {
> 14   H(D,D);
> 15 }
>
> It would be a category error if we asked:
> Does D correctly simulated by H really want a large glass of cold milk?

Right. just as it is a category error to look at anything but a CORRECT
simulation of D, which means that the simulation CAN NOT stop until it
reaches a final state.

>
>> Input is text
>
> and D correctly simulated by H provides the behavior actually specified
> by this text.

Yes, the behavior of the correct simulation of the text, is BY
DEFINITION, the behavior of a UTM simulating this input (which will
never abort its simulation) which will exactly match the behavior of a
direct call of D(D).

You just don't seem to understand the meaning of "Correct" here.

>
>> and text does not halt or fail to halt. The requirement is that H
>> tells whether the input is a decription of a halting or non-halting
>> computation.
>>
>> Mikko
>>
>

On 8/20/23 12:06 PM, olcott wrote:
> On 8/20/2023 3:32 AM, Mikko wrote:
>> On 2023-08-19 23:02:11 +0000, olcott said:
>>
>>> If D correctly simulated by H cannot possibly terminate normally then
>>> this proves that the actual behavior of the actual input is non-halting.
>>
>> D correctly simulated by H does not even exist unless H correctly
>> simulates
>> D. However, there is not need to say anything about "D correctly
>> simulated
>> by H" because pain "D" is sufficient.
>>
>> H's simulation of D is another thing. It is not the same as D although
>> there is some similarity if H simulates correctly.
>>
>>> A halt decider is required to report on the actual behavior of the
>>> actual input and it not allowed to report on any other behavior.
>>
>> A decider is required to tell whether a text is of the kind that
>> the decider is required to identify. For a halt decider the requirement
>> is that the text is a description of a halting computation.
>>
>> Mikko
>>
>
> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
>
> *Thu 10/13/2022 11:29 AM email from*
> MIT Professor Michael Sipser has agreed that the following verbatim
> words are correct (he has not agreed to anything else):
>
> 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.
>

Right, And remember, that to him, as to the rest of the world, the ONLY
"Correct results" of a "Simulation" is that of a UTM, i.e. a simulation
that never aborts.

Also, BY DEFINITION, the input reference the H that was INITIALLY
defined, that is, the one that gives the final answer.

Since this H does abort is simulation and returns 0, the only "Correct
Simulation" of the input is one that shows that.

Your presumption of an alternate H changes just the H doing the
decision, not the H that D calls, (because that is how Turing Machines
work) and if we change the outer H to be H' that doesn't abort, then we
see that it will see that D calls H(D,D) which WILL abort its simulation
(since that IS what happens in the actual H) and returns o to D and D halts.

THerefore, your condtion, that H can correctly determine that a correct
simulation of its input would not halt, is just a false statement.

Your problem is your logic changes the code of the input to H, which
logic doesn't allow. D doesn't call the H that is currently deciding on
it, but the H that is claimed to give the right result, which doesn't
change in your hypothetical case.

Thus, by your own words, you have proven yourself to be a pathetic liar,
since you are looking at an input other than the input actually given to
H (which calls the H that give the claimed right answer, which is the H
that does abort and returns 0).

You are just showing that you don't understand the basic rules of logic,
you need to start form TRUE premises to make conclusions.

On 2023-08-19 23:02:11 +0000, olcott said:

> If D correctly simulated by H cannot possibly terminate normally then
> this proves that the actual behavior of the actual input is non-halting.

Irrelevant.

> A halt decider is required to report on the actual behavior of the
> actual input and it not allowed to report on any other behavior.

Wrong. A halt decider is required to report whether the actual
computation it is asked about therminates.

For eample, Wikipedia https://en.wikipedia.org/wiki/Halting_problem
defines the problem: "In computability theory, the halting problem is the
problem of determining, from a description of an arbitrary computer program
and an input, whether the program will finish running, or continue to run
forever."

Mikko

On 2023-08-20 16:06:32 +0000, olcott said:

> On 8/20/2023 3:32 AM, Mikko wrote:
>> On 2023-08-19 23:02:11 +0000, olcott said:
>>
>>> If D correctly simulated by H cannot possibly terminate normally then
>>> this proves that the actual behavior of the actual input is non-halting.
>>
>> D correctly simulated by H does not even exist unless H correctly simulates
>> D. However, there is not need to say anything about "D correctly simulated
>> by H" because pain "D" is sufficient.
>>
>> H's simulation of D is another thing. It is not the same as D although
>> there is some similarity if H simulates correctly.
>>
>>> A halt decider is required to report on the actual behavior of the
>>> actual input and it not allowed to report on any other behavior.
>>
>> A decider is required to tell whether a text is of the kind that
>> the decider is required to identify. For a halt decider the requirement
>> is that the text is a description of a halting computation.
>>
>> Mikko
>>
>
> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
>
>
> *Thu 10/13/2022 11:29 AM email from*
> MIT Professor Michael Sipser has agreed that the following verbatim
> words are correct (he has not agreed to anything else):

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

His opinion is that this statement is true. However, his opinion is not
a definition. If you want prove something, you must start with definitons,
not with opinions.

Mikko

On 8/21/2023 5:50 AM, Mikko wrote:
> On 2023-08-19 23:02:11 +0000, olcott said:
>
>> If D correctly simulated by H cannot possibly terminate normally then
>> this proves that the actual behavior of the actual input is non-halting.
>
> Irrelevant.
>
>> A halt decider is required to report on the actual behavior of the
>> actual input and it not allowed to report on any other behavior.
>
> Wrong. A halt decider is required to report whether the actual
> computation it is asked about therminates.

All deciders must map THEIR INPUT to an accept or reject state
on the basis of a property of THIS INPUT.

All halt deciders must map THEIR INPUT to an accept or reject state
on the basis of the behavior specified by THIS ACTUAL INPUT.

The actual behavior specified by this actual input is the behavior
of D correctly simulated by H. This behavior of this input must
include the change in the behavior caused by the pathological
relationship specified by the source code.

I don't know how my reviewers think that they can get away with
different behavior than the behavior that the source-code stipulates.

When the source code stipulates that D simulated by H cannot possibly
terminate normally then this must be reported as non-halting.

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

On 8/21/2023 5:54 AM, Mikko wrote:
> On 2023-08-20 16:06:32 +0000, olcott said:
>
>> On 8/20/2023 3:32 AM, Mikko wrote:
>>> On 2023-08-19 23:02:11 +0000, olcott said:
>>>
>>>> If D correctly simulated by H cannot possibly terminate normally then
>>>> this proves that the actual behavior of the actual input is
>>>> non-halting.
>>>
>>> D correctly simulated by H does not even exist unless H correctly
>>> simulates
>>> D. However, there is not need to say anything about "D correctly
>>> simulated
>>> by H" because pain "D" is sufficient.
>>>
>>> H's simulation of D is another thing. It is not the same as D although
>>> there is some similarity if H simulates correctly.
>>>
>>>> A halt decider is required to report on the actual behavior of the
>>>> actual input and it not allowed to report on any other behavior.
>>>
>>> A decider is required to tell whether a text is of the kind that
>>> the decider is required to identify. For a halt decider the requirement
>>> is that the text is a description of a halting computation.
>>>
>>> Mikko
>>>
>>
>> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
>>
>> *Thu 10/13/2022 11:29 AM email from*
>> MIT Professor Michael Sipser has agreed that the following verbatim
>> words are correct (he has not agreed to anything else):
>
>> 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.
>
> His opinion is that this statement is true. However, his opinion is not
> a definition. If you want prove something, you must start with definitons,
> not with opinions.
>
> Mikko
>

He agreed with my verbatim words. Many people noticed that these
words are a tautology thus a necessary truth.

When D correctly simulated by H cannot possibly terminate normally
and halting requires terminating normally then the D input to H
is necessarily non-halting.

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

On 8/21/23 10:49 AM, olcott wrote:
> On 8/21/2023 5:50 AM, Mikko wrote:
>> On 2023-08-19 23:02:11 +0000, olcott said:
>>
>>> If D correctly simulated by H cannot possibly terminate normally then
>>> this proves that the actual behavior of the actual input is non-halting.
>>
>> Irrelevant.
>>
>>> A halt decider is required to report on the actual behavior of the
>>> actual input and it not allowed to report on any other behavior.
>>
>> Wrong. A halt decider is required to report whether the actual
>> computation it is asked about therminates.
>
> All deciders must map THEIR INPUT to an accept or reject state
> on the basis of a property of THIS INPUT.
>
> All halt deciders must map THEIR INPUT to an accept or reject state
> on the basis of the behavior specified by THIS ACTUAL INPUT.
>
> The actual behavior specified by this actual input is the behavior
> of D correctly simulated by H. This behavior of this input must
> include the change in the behavior caused by the pathological
> relationship specified by the source code.
>
> I don't know how my reviewers think that they can get away with
> different behavior than the behavior that the source-code stipulates.
>
> When the source code stipulates that D simulated by H cannot possibly
> terminate normally then this must be reported as non-halting.
>
>

ANd H's input is (or at least must be if you are following the proof) a
description of the computation D(D) where D is calls THIS H and asks
what that computation does.

So, guess you are just admitting that you are a LIAR, as you haven't
built D correctly.

Also, if H is a "Halt Decider", then the question is NOT "Can H simulate
the input to a final state", but does the machine represented by the
input reach a final state when run (or CORRECTLY simulated).

I guess that just shows your nature, that of an ignorant pathologica liar.

You can't "stipulate" that something is true, just what meaning you are
using for a word, and if that disagres with the ACTUAL definition of the
word, you are just stipulating that you logic doesn't apply to it.

PROOF, you are wrong.

On 2023-08-21 14:49:13 +0000, olcott said:

> All deciders must map THEIR INPUT to an accept or reject state
> on the basis of a property of THIS INPUT.

That is the only thing they can do, eeven if required something else.

For a halting deider the property is whether that input is a
description of a halting computation.

> All halt deciders must map THEIR INPUT to an accept or reject state
> on the basis of the behavior specified by THIS ACTUAL INPUT.

Which is the actual behaviour of the actual Turing machine
described by the input.

> The actual behavior specified by this actual input is the behavior
> of D correctly simulated by H.

So you say but haven't proven. Instead, you have proven that it is not.

> This behavior of this input must
> include the change in the behavior caused by the pathological
> relationship specified by the source code.

There is no change in the behaviour. Id D(D) ever halts it halts,
otherwise it never halts.

> I don't know how my reviewers think that they can get away with
> different behavior than the behavior that the source-code stipulates.

Source code does not stipulate. It describes. If H sees a different
behaviour it interpretes the input incorrectly.

> When the source code stipulates that D simulated by H cannot possibly
> terminate normally then this must be reported as non-halting.

Source code says nothing about H, only about D.

Mikko

On 2023-08-21 14:54:19 +0000, olcott said:

> On 8/21/2023 5:54 AM, Mikko wrote:
>> On 2023-08-20 16:06:32 +0000, olcott said:
>>
>>> On 8/20/2023 3:32 AM, Mikko wrote:
>>>> On 2023-08-19 23:02:11 +0000, olcott said:
>>>>
>>>>> If D correctly simulated by H cannot possibly terminate normally then
>>>>> this proves that the actual behavior of the actual input is non-halting.
>>>>
>>>> D correctly simulated by H does not even exist unless H correctly simulates
>>>> D. However, there is not need to say anything about "D correctly simulated
>>>> by H" because pain "D" is sufficient.
>>>>
>>>> H's simulation of D is another thing. It is not the same as D although
>>>> there is some similarity if H simulates correctly.
>>>>
>>>>> A halt decider is required to report on the actual behavior of the
>>>>> actual input and it not allowed to report on any other behavior.
>>>>
>>>> A decider is required to tell whether a text is of the kind that
>>>> the decider is required to identify. For a halt decider the requirement
>>>> is that the text is a description of a halting computation.
>>>>
>>>> Mikko
>>>>
>>>
>>> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
>>>
>>>
>>> *Thu 10/13/2022 11:29 AM email from*
>>> MIT Professor Michael Sipser has agreed that the following verbatim
>>> words are correct (he has not agreed to anything else):
>>
>>> 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.
>>
>> His opinion is that this statement is true. However, his opinion is not
>> a definition. If you want prove something, you must start with definitons,
>> not with opinions.
>>
>> Mikko
>>
>
> He agreed with my verbatim words.

An agreement of opionions is not a proof.

> Many people noticed that these words are a tautology thus
> a necessary truth.

That is a semantic tautology, i.e., it is a tautology only if correctly
interpreted.

> When D correctly simulated by H cannot possibly terminate normally
> and halting requires terminating normally then the D input to H
> is necessarily non-halting.

The D that H simulates does terminate normally. H just fails to simulate
D to normal termination.

Mikko

On 8/21/23 10:54 AM, olcott wrote:
> On 8/21/2023 5:54 AM, Mikko wrote:
>> On 2023-08-20 16:06:32 +0000, olcott said:
>>
>>> On 8/20/2023 3:32 AM, Mikko wrote:
>>>> On 2023-08-19 23:02:11 +0000, olcott said:
>>>>
>>>>> If D correctly simulated by H cannot possibly terminate normally then
>>>>> this proves that the actual behavior of the actual input is
>>>>> non-halting.
>>>>
>>>> D correctly simulated by H does not even exist unless H correctly
>>>> simulates
>>>> D. However, there is not need to say anything about "D correctly
>>>> simulated
>>>> by H" because pain "D" is sufficient.
>>>>
>>>> H's simulation of D is another thing. It is not the same as D although
>>>> there is some similarity if H simulates correctly.
>>>>
>>>>> A halt decider is required to report on the actual behavior of the
>>>>> actual input and it not allowed to report on any other behavior.
>>>>
>>>> A decider is required to tell whether a text is of the kind that
>>>> the decider is required to identify. For a halt decider the requirement
>>>> is that the text is a description of a halting computation.
>>>>
>>>> Mikko
>>>>
>>>
>>> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
>>>
>>> *Thu 10/13/2022 11:29 AM email from*
>>> MIT Professor Michael Sipser has agreed that the following verbatim
>>> words are correct (he has not agreed to anything else):
>>
>>> 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.
>>
>> His opinion is that this statement is true. However, his opinion is not
>> a definition. If you want prove something, you must start with
>> definitons,
>> not with opinions.
>>
>> Mikko
>>
>
> He agreed with my verbatim words. Many people noticed that these
> words are a tautology thus a necessary truth.
>
> When D correctly simulated by H cannot possibly terminate normally
> and halting requires terminating normally then the D input to H
> is necessarily non-halting.
>

And since H DOESN'T "Correctly Simulste" its input, or even predict what
a "Correct Simuliation" of it would be, all you are doing is proving
your ignorance of the topic.

On 8/22/2023 4:56 AM, Mikko wrote:
> On 2023-08-21 14:49:13 +0000, olcott said:
>
>> All deciders must map THEIR INPUT to an accept or reject state
>> on the basis of a property of THIS INPUT.
>
> That is the only thing they can do, eeven if required something else.
>
> For a halting deider the property is whether that input is a
> description of a halting computation.
>
>> All halt deciders must map THEIR INPUT to an accept or reject state
>> on the basis of the behavior specified by THIS ACTUAL INPUT.
>
> Which is the actual behaviour of the actual Turing machine
> described by the input.

THIS CANNOT IGNORE THE CHANGE IN BEHAVIOR CAUSED BY THE SPECIFIED
PATHOLOGICAL RELATIONSHIP THAT IS STIPULATED BY THE SOURCE-CODE OF
D AND H.

>> The actual behavior specified by this actual input is the behavior
>> of D correctly simulated by H.
>
> So you say but haven't proven. Instead, you have proven that it is not.

I have proven it many times and yet my reviewers insist on a break
from reality by making sure to ignore that actual behavior that is
actually specified by the source-code of D and H that specifies their
pathological relationship to each other.

// The following is written in C
//
01 typedef int (*ptr)(); // pointer to int function
02 int H(ptr x, ptr y) // uses x86 emulator to simulate its input
03
04 int D(ptr x)
05 {
06 int Halt_Status = H(x, x);
07 if (Halt_Status)
08 HERE: goto HERE;
09 return Halt_Status;
10 }
11
12 void main()
13 {
14 H(D,D);
15 }

*Execution Trace*
Line 14: main() invokes H(D,D);

*keeps repeating* (unless aborted)
Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)

*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 06.

It is an easily verified fact that D correctly simulated by H cannot
possibly reach past its own line 06. The only way to disagree with this
is through a break from reality.

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

On 8/22/2023 5:16 AM, Mikko wrote:
> On 2023-08-21 14:54:19 +0000, olcott said:
>
>> On 8/21/2023 5:54 AM, Mikko wrote:
>>> On 2023-08-20 16:06:32 +0000, olcott said:
>>>
>>>> On 8/20/2023 3:32 AM, Mikko wrote:
>>>>> On 2023-08-19 23:02:11 +0000, olcott said:
>>>>>
>>>>>> If D correctly simulated by H cannot possibly terminate normally then
>>>>>> this proves that the actual behavior of the actual input is
>>>>>> non-halting.
>>>>>
>>>>> D correctly simulated by H does not even exist unless H correctly
>>>>> simulates
>>>>> D. However, there is not need to say anything about "D correctly
>>>>> simulated
>>>>> by H" because pain "D" is sufficient.
>>>>>
>>>>> H's simulation of D is another thing. It is not the same as D although
>>>>> there is some similarity if H simulates correctly.
>>>>>
>>>>>> A halt decider is required to report on the actual behavior of the
>>>>>> actual input and it not allowed to report on any other behavior.
>>>>>
>>>>> A decider is required to tell whether a text is of the kind that
>>>>> the decider is required to identify. For a halt decider the
>>>>> requirement
>>>>> is that the text is a description of a halting computation.
>>>>>
>>>>> Mikko
>>>>>
>>>>
>>>> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
>>>>
>>>> *Thu 10/13/2022 11:29 AM email from*
>>>> MIT Professor Michael Sipser has agreed that the following verbatim
>>>> words are correct (he has not agreed to anything else):
>>>
>>>> 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.
>>>
>>> His opinion is that this statement is true. However, his opinion is not
>>> a definition. If you want prove something, you must start with
>>> definitons,
>>> not with opinions.
>>>
>>> Mikko
>>>
>>
>> He agreed with my verbatim words.
>
> An agreement of opionions is not a proof.
>
>> Many people noticed that these words are a tautology thus
>> a necessary truth.
>
> That is a semantic tautology, i.e., it is a tautology only if correctly
> interpreted.
>
>> When D correctly simulated by H cannot possibly terminate normally
>> and halting requires terminating normally then the D input to H
>> is necessarily non-halting.
>
> The D that H simulates does terminate normally. H just fails to simulate
> D to normal termination.
>
> Mikko
>

It is the fact that a correct simulation of D by H causes H to
continue to call H that makes it impossible for D correctly simulated
by H to terminate normally.

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

On 8/22/23 11:09 AM, olcott wrote:
> On 8/22/2023 4:56 AM, Mikko wrote:
>> On 2023-08-21 14:49:13 +0000, olcott said:
>>
>>> All deciders must map THEIR INPUT to an accept or reject state
>>> on the basis of a property of THIS INPUT.
>>
>> That is the only thing they can do, eeven if required something else.
>>
>> For a halting deider the property is whether that input is a
>> description of a halting computation.
>>
>>> All halt deciders must map THEIR INPUT to an accept or reject state
>>> on the basis of the behavior specified by THIS ACTUAL INPUT.
>>
>> Which is the actual behaviour of the actual Turing machine
>> described by the input.
>
> THIS CANNOT IGNORE THE CHANGE IN BEHAVIOR CAUSED BY THE SPECIFIED
> PATHOLOGICAL RELATIONSHIP THAT IS STIPULATED BY THE SOURCE-CODE OF
> D AND H.

It doesn't "Change the behavior" because the behavior of a program is
fixed the moment the program comes into existance.

Tha ACTUAL behavior of a correct simulation of a Turing Machine is the
same as the ACTUAL behavior of the direct running of it.

The behavior of H for all inputs was FIXED the moment you actually
defined H as a actual program. From that behavior, we can define a
program D that does this "pathological" relationship.

The only way H can try to defeat this, is to not actually BE a
"program", which seems to be the nature of your logic, claiming that H
does something that H doesn't do.

In other words, you are just admitting to LYING about what you are doing.

>
>>> The actual behavior specified by this actual input is the behavior
>>> of D correctly simulated by H.
>>
>> So you say but haven't proven. Instead, you have proven that it is not.
>
> I have proven it many times and yet my reviewers insist on a break
> from reality by making sure to ignore that actual behavior that is
> actually specified by the source-code of D and H that specifies their
> pathological relationship to each other.

The ACTUAL behavior of D(D), bassed on your actual provided definition
of H is to Halt.

The ACTUAL behavior of H(D,D), is to say "Non-Halting".

BY DEFINITION, this says that H is NOT a "Halt Decider".

Your logic is incorrect, because you claim H somehow "does a correct
simulation" when it actually doesn't, because you just LIE about how H
behaves, even when that behavior is easily proven.

>
> // The following is written in C
> //
> 01 typedef int (*ptr)(); // pointer to int function
> 02 int H(ptr x, ptr y)   // uses x86 emulator to simulate its input
> 03
> 04 int D(ptr x)
> 05 {
> 06   int Halt_Status = H(x, x);
> 07   if (Halt_Status)
> 08     HERE: goto HERE;
> 09   return Halt_Status;
> 10 }
> 11
> 12 void main()
> 13 {
> 14   H(D,D);
> 15 }
>
> *Execution Trace*
> Line 14: main() invokes H(D,D);
>
> *keeps repeating* (unless aborted)

Nope, ABORTS Because that is what H is programed to Do.

You just don't understand the vocabulary of programs.

> Line 06: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>
> *Simulation invariant*
> D correctly simulated by H cannot possibly reach past its own line 06.

No, the INCORRECT simulation done by H aborts at that point.

THE CORRECT SIMULATION of the input, which THIS H can't do, shows that
the input represents a Halting Compuation.

>
> It is an easily verified fact that D correctly simulated by H cannot
> possibly reach past its own line 06. The only way to disagree with this
> is through a break from reality.
>

No, it is easily verified that H does not "correctly simulate" its input.

And, that you don't understand what "Reality" or "Truth" actually mean.

Whch is why you are shown to be just a blantant liar.

On 8/22/23 11:12 AM, olcott wrote:
> On 8/22/2023 5:16 AM, Mikko wrote:
>> On 2023-08-21 14:54:19 +0000, olcott said:
>>
>>> On 8/21/2023 5:54 AM, Mikko wrote:
>>>> On 2023-08-20 16:06:32 +0000, olcott said:
>>>>
>>>>> On 8/20/2023 3:32 AM, Mikko wrote:
>>>>>> On 2023-08-19 23:02:11 +0000, olcott said:
>>>>>>
>>>>>>> If D correctly simulated by H cannot possibly terminate normally
>>>>>>> then
>>>>>>> this proves that the actual behavior of the actual input is
>>>>>>> non-halting.
>>>>>>
>>>>>> D correctly simulated by H does not even exist unless H correctly
>>>>>> simulates
>>>>>> D. However, there is not need to say anything about "D correctly
>>>>>> simulated
>>>>>> by H" because pain "D" is sufficient.
>>>>>>
>>>>>> H's simulation of D is another thing. It is not the same as D
>>>>>> although
>>>>>> there is some similarity if H simulates correctly.
>>>>>>
>>>>>>> A halt decider is required to report on the actual behavior of the
>>>>>>> actual input and it not allowed to report on any other behavior.
>>>>>>
>>>>>> A decider is required to tell whether a text is of the kind that
>>>>>> the decider is required to identify. For a halt decider the
>>>>>> requirement
>>>>>> is that the text is a description of a halting computation.
>>>>>>
>>>>>> Mikko
>>>>>>
>>>>>
>>>>> https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X
>>>>>
>>>>> *Thu 10/13/2022 11:29 AM email from*
>>>>> MIT Professor Michael Sipser has agreed that the following verbatim
>>>>> words are correct (he has not agreed to anything else):
>>>>
>>>>> 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.
>>>>
>>>> His opinion is that this statement is true. However, his opinion is not
>>>> a definition. If you want prove something, you must start with
>>>> definitons,
>>>> not with opinions.
>>>>
>>>> Mikko
>>>>
>>>
>>> He agreed with my verbatim words.
>>
>> An agreement of opionions is not a proof.
>>
>>> Many people noticed that these words are a tautology thus
>>> a necessary truth.
>>
>> That is a semantic tautology, i.e., it is a tautology only if correctly
>> interpreted.
>>
>>> When D correctly simulated by H cannot possibly terminate normally
>>> and halting requires terminating normally then the D input to H
>>> is necessarily non-halting.
>>
>> The D that H simulates does terminate normally. H just fails to simulate
>> D to normal termination.
>>
>> Mikko
>>
>
> It is the fact that a correct simulation of D by H causes H to
> continue to call H that makes it impossible for D correctly simulated
> by H to terminate normally.
>
>

No, that s a *LIE* because this H does actually DO a correct simulation.
PERIOD.

It is a DIFFERENT H, and thus a DIFFERENT D (since D depends on the
decider it is built on), and thus not applicaple for THIS H and THIS D.

You are just proving you don't understand the question, or even what a
"program" is.

Since this has been explained to you many times, it isn't "just an
honest mistake" but just shows that you are a blantant liar.