XPost: comp.theory, sci.logic

On 5/20/2023 8:49 AM, Richard Damon wrote:

On 5/20/23 12:00 AM, olcott wrote:

On 5/19/2023 10:27 PM, Richard Damon wrote:

On 5/19/23 11:00 PM, olcott wrote:

On 5/19/2023 9:51 PM, Richard Damon wrote:

On 5/19/23 10:10 PM, olcott wrote:

On 5/19/2023 8:56 PM, Richard Damon wrote:

On 5/19/23 9:47 PM, olcott wrote:

On 5/19/2023 5:54 PM, Richard Damon wrote:

On 5/19/23 10:50 AM, olcott wrote:

Can D simulated by H terminate normally?

Wrong Question!

In other words the question is over you head.
It took me many years to recognize this same dodge by Ben.

No, it is the WRONG question once you try to apply the answer to >>>>>>> the Halting Problem, which you do.

So the software engineering really is over your head?
I see, so like Ben you have never actually written any code.

But you aren't talking about Software Engineering unless you are
lying about this applying to the Halting Problem described by Linz,
since that is the Halting Problem of Computability Theory.

Of course, the likely explanation is that you are just ignorant of
what you are talking about, so you don't understand the diference.

Ben kept masking his coding incompetence this way.
It never occurred to me that you have never written any code.

I have possibly written more WORKING code than you have.

I don't believe you. Your inability to answer an straight forward
software engineering question seems to prove otherwise.

What software engineering question?

Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?

The answer to that question is NO,

Finally you admit an easily verified fact.

but that is because H doesn't, and
can never do an accurarte simulation per the definition of a UTM.

If the simulation by a UTM would be wrong then you would have to be able
to point out the mistake in the simulation of D by H,

because H and D are isomorphic to embedded_H and ⟨Ĥ⟩

yet you already admitted that the simulation by H does prevent the
simulated D from terminating normally. So you have painted yourself in a
corner on this.


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

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

XPost: comp.theory, sci.logic

On 5/20/2023 10:19 AM, Richard Damon wrote:

On 5/20/23 10:54 AM, olcott wrote:

On 5/20/2023 8:49 AM, Richard Damon wrote:

On 5/20/23 12:00 AM, olcott wrote:

On 5/19/2023 10:27 PM, Richard Damon wrote:

On 5/19/23 11:00 PM, olcott wrote:

On 5/19/2023 9:51 PM, Richard Damon wrote:

On 5/19/23 10:10 PM, olcott wrote:

On 5/19/2023 8:56 PM, Richard Damon wrote:

On 5/19/23 9:47 PM, olcott wrote:

On 5/19/2023 5:54 PM, Richard Damon wrote:

On 5/19/23 10:50 AM, olcott wrote:

Can D simulated by H terminate normally?

Wrong Question!

In other words the question is over you head.
It took me many years to recognize this same dodge by Ben.

No, it is the WRONG question once you try to apply the answer >>>>>>>>> to the Halting Problem, which you do.

So the software engineering really is over your head?
I see, so like Ben you have never actually written any code.

But you aren't talking about Software Engineering unless you are >>>>>>> lying about this applying to the Halting Problem described by
Linz, since that is the Halting Problem of Computability Theory. >>>>>>>
Of course, the likely explanation is that you are just ignorant
of what you are talking about, so you don't understand the
diference.

Ben kept masking his coding incompetence this way.
It never occurred to me that you have never written any code.

I have possibly written more WORKING code than you have.

I don't believe you. Your inability to answer an straight forward
software engineering question seems to prove otherwise.

What software engineering question?

Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?

The answer to that question is NO,

Finally you admit an easily verified fact.

but that is because H doesn't, and can never do an accurarte
simulation per the definition of a UTM.

If the simulation by a UTM would be wrong then you would have to be able
to point out the mistake in the simulation of D by H,

No, the simulation by a ACTUAL UTM will reach a final state.

I don't know why you say this when you already know that ⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly terminate normally.

When Ĥ is applied to ⟨Ĥ⟩
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

N steps of ⟨Ĥ⟩ correctly simulated by embedded_H are the actual behavior of this input:
(a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to embedded_H
(b) embedded_H is applied to ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) which simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
(c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process


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

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

XPost: comp.theory, sci.logic

On 5/20/23 10:54 AM, olcott wrote:

On 5/20/2023 8:49 AM, Richard Damon wrote:

On 5/20/23 12:00 AM, olcott wrote:

On 5/19/2023 10:27 PM, Richard Damon wrote:

On 5/19/23 11:00 PM, olcott wrote:

On 5/19/2023 9:51 PM, Richard Damon wrote:

On 5/19/23 10:10 PM, olcott wrote:

On 5/19/2023 8:56 PM, Richard Damon wrote:

On 5/19/23 9:47 PM, olcott wrote:

On 5/19/2023 5:54 PM, Richard Damon wrote:

On 5/19/23 10:50 AM, olcott wrote:

Can D simulated by H terminate normally?

Wrong Question!

In other words the question is over you head.
It took me many years to recognize this same dodge by Ben.

No, it is the WRONG question once you try to apply the answer to >>>>>>>> the Halting Problem, which you do.

So the software engineering really is over your head?
I see, so like Ben you have never actually written any code.

But you aren't talking about Software Engineering unless you are
lying about this applying to the Halting Problem described by
Linz, since that is the Halting Problem of Computability Theory.

Of course, the likely explanation is that you are just ignorant of >>>>>> what you are talking about, so you don't understand the diference. >>>>>>

Ben kept masking his coding incompetence this way.
It never occurred to me that you have never written any code.

I have possibly written more WORKING code than you have.

I don't believe you. Your inability to answer an straight forward
software engineering question seems to prove otherwise.

What software engineering question?

Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?

The answer to that question is NO,

Finally you admit an easily verified fact.

but that is because H doesn't, and can never do an accurarte
simulation per the definition of a UTM.

If the simulation by a UTM would be wrong then you would have to be able
to point out the mistake in the simulation of D by H,

No, the simulation by a ACTUAL UTM will reach a final state.

H, which isn't a UTM, can't do that.

because H and D are isomorphic to embedded_H and ⟨Ĥ⟩

No, D is Ĥ, &D is (Ĥ)

yet you already admitted that the simulation by H does prevent the
simulated D from terminating normally. So you have painted yourself in a corner on this.

Right, because H isn't a UTM. If it was, it would fail to answer, and
thus not be a decider. (By Definition, UTM of a non-halting input never
halts and gives an answer, so if H WAS a UTM, it could never correctly
answer non-halting, doing so makes it NOT a UTM).

YOU have shown yourself to be a LIAR, because this has been explained to
you before, and you refuse to learn it.

UTM(D,D) will Halt, since D(D) will Halt because H(D,D) returns 0.

Thus H(D,D) returning 0 is INCORRECT.

Only because you stupidily think you can just "define" H to be a UTM
"plus" when it fails to meet the requirements of a UTM, can you even
attempt your unsound and invalid arguement.

Basically, we have a case where you are told that Jack knows the answer
to the problem, so you ask Jim for the answer. Even if you ask Jim what
would Jack say, since Jim doesn't know the answer, either he doesn't
answer or he lies, or he just makes up an answer.

The UTM is Jack.

Your H is Jim, it isn't actually a UTM, so it doesn't actually have the
answer in this case, so it needs to either blatantly lie, or just guess,
and due to the structure of D, it will always guess wrong.

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

XPost: comp.theory, sci.logic

On 5/20/23 11:24 AM, olcott wrote:

On 5/20/2023 10:19 AM, Richard Damon wrote:

On 5/20/23 10:54 AM, olcott wrote:

On 5/20/2023 8:49 AM, Richard Damon wrote:

On 5/20/23 12:00 AM, olcott wrote:

On 5/19/2023 10:27 PM, Richard Damon wrote:

On 5/19/23 11:00 PM, olcott wrote:

On 5/19/2023 9:51 PM, Richard Damon wrote:

On 5/19/23 10:10 PM, olcott wrote:

On 5/19/2023 8:56 PM, Richard Damon wrote:

On 5/19/23 9:47 PM, olcott wrote:

On 5/19/2023 5:54 PM, Richard Damon wrote:

On 5/19/23 10:50 AM, olcott wrote:

Can D simulated by H terminate normally?

Wrong Question!

In other words the question is over you head.
It took me many years to recognize this same dodge by Ben. >>>>>>>>>>

No, it is the WRONG question once you try to apply the answer >>>>>>>>>> to the Halting Problem, which you do.

So the software engineering really is over your head?
I see, so like Ben you have never actually written any code.

But you aren't talking about Software Engineering unless you are >>>>>>>> lying about this applying to the Halting Problem described by
Linz, since that is the Halting Problem of Computability Theory. >>>>>>>>
Of course, the likely explanation is that you are just ignorant >>>>>>>> of what you are talking about, so you don't understand the
diference.

Ben kept masking his coding incompetence this way.
It never occurred to me that you have never written any code. >>>>>>>>

I have possibly written more WORKING code than you have.

I don't believe you. Your inability to answer an straight forward >>>>>>> software engineering question seems to prove otherwise.

What software engineering question?

Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?

The answer to that question is NO,

Finally you admit an easily verified fact.

but that is because H doesn't, and can never do an accurarte
simulation per the definition of a UTM.

If the simulation by a UTM would be wrong then you would have to be able >>> to point out the mistake in the simulation of D by H,

No, the simulation by a ACTUAL UTM will reach a final state.

I don't know why you say this when you already know that ⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly terminate normally.

Because embedded_H doesn't actually "Correctly Simulate" its input by
the definintion aquired by your mentioning of a UTM.

Remember, as you have previously pointed out, very word/phrase in a
natural language sentence implicitly has a UUID attached to it to
indicate which of its meanings this use has. When we are talking about a
UTM, the ONLY definition of "Correctly Simulate" that matches, as a
COMPLETE simulation. (Maybe your problem is you don't really understand
what a UTM is). Since the phrase "Correctly Simulates" means completly simulates, and embedded_H doesn't do that, since it DOES abort its
simulation, your statement of "correctly simulated by embedded_H" is a statement built on a false premise, and thus unsound.

Thus, your whole arguement fails.

You can't change H / embedded_H to be some other program beside the one
claimed (which does abort) or that means that your Ĥ isn't the Ĥ from
the problem.

You are just showing you are a stupid and ignorant pathological liar.

When Ĥ is applied to ⟨Ĥ⟩
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

N steps of ⟨Ĥ⟩ correctly simulated by embedded_H are the actual behavior of this input:

Which isn't "Correctly Simulated" per the meaning of the words as
implied by your invoking of the concept of a UTM.

(a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to embedded_H
(b) embedded_H is applied to ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) which simulates
⟨Ĥ⟩ applied to ⟨Ĥ⟩
(c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process

And in actuality, (c) doesn't continue the process as the outer
embedded_H aborts its simulation, and returns (incorrectly) non-halting
and the input machine, which then halts.

So a CORRECTLY simulated input will halt, it is just that embedded_H
aborts its simulation, so gets the wrong answer.

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

XPost: comp.theory, sci.logic

On 5/20/2023 11:10 AM, Richard Damon wrote:

On 5/20/23 11:24 AM, olcott wrote:

On 5/20/2023 10:19 AM, Richard Damon wrote:

On 5/20/23 10:54 AM, olcott wrote:

On 5/20/2023 8:49 AM, Richard Damon wrote:

On 5/20/23 12:00 AM, olcott wrote:

On 5/19/2023 10:27 PM, Richard Damon wrote:

On 5/19/23 11:00 PM, olcott wrote:

On 5/19/2023 9:51 PM, Richard Damon wrote:

On 5/19/23 10:10 PM, olcott wrote:

On 5/19/2023 8:56 PM, Richard Damon wrote:

On 5/19/23 9:47 PM, olcott wrote:

On 5/19/2023 5:54 PM, Richard Damon wrote:

On 5/19/23 10:50 AM, olcott wrote:

Can D simulated by H terminate normally?

Wrong Question!

In other words the question is over you head.
It took me many years to recognize this same dodge by Ben. >>>>>>>>>>>

No, it is the WRONG question once you try to apply the answer >>>>>>>>>>> to the Halting Problem, which you do.

So the software engineering really is over your head?
I see, so like Ben you have never actually written any code. >>>>>>>>>

But you aren't talking about Software Engineering unless you >>>>>>>>> are lying about this applying to the Halting Problem described >>>>>>>>> by Linz, since that is the Halting Problem of Computability
Theory.

Of course, the likely explanation is that you are just ignorant >>>>>>>>> of what you are talking about, so you don't understand the
diference.

Ben kept masking his coding incompetence this way.
It never occurred to me that you have never written any code. >>>>>>>>>

I have possibly written more WORKING code than you have.

I don't believe you. Your inability to answer an straight forward >>>>>>>> software engineering question seems to prove otherwise.

What software engineering question?

Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?

The answer to that question is NO,

Finally you admit an easily verified fact.

but that is because H doesn't, and can never do an accurarte
simulation per the definition of a UTM.

If the simulation by a UTM would be wrong then you would have to be
able
to point out the mistake in the simulation of D by H,

No, the simulation by a ACTUAL UTM will reach a final state.

I don't know why you say this when you already know that ⟨Ĥ⟩ correctly >> simulated by embedded_H cannot possibly terminate normally.

Because embedded_H doesn't actually "Correctly Simulate" its input by
the definintion aquired by your mentioning of a UTM.

You have already agreed that it does simulate the first N steps
correctly. It is just as obvious that the behavior pattern of N steps of ⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly terminate normally even if the value of N is ∞.

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

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

XPost: comp.theory, sci.logic

On 5/20/2023 1:15 PM, Richard Damon wrote:

On 5/20/23 1:09 PM, olcott wrote:

On 5/20/2023 11:10 AM, Richard Damon wrote:

On 5/20/23 11:24 AM, olcott wrote:

On 5/20/2023 10:19 AM, Richard Damon wrote:

On 5/20/23 10:54 AM, olcott wrote:

On 5/20/2023 8:49 AM, Richard Damon wrote:

On 5/20/23 12:00 AM, olcott wrote:

On 5/19/2023 10:27 PM, Richard Damon wrote:

On 5/19/23 11:00 PM, olcott wrote:

On 5/19/2023 9:51 PM, Richard Damon wrote:

On 5/19/23 10:10 PM, olcott wrote:

On 5/19/2023 8:56 PM, Richard Damon wrote:

On 5/19/23 9:47 PM, olcott wrote:

On 5/19/2023 5:54 PM, Richard Damon wrote:

On 5/19/23 10:50 AM, olcott wrote:

Can D simulated by H terminate normally?

Wrong Question!

In other words the question is over you head.
It took me many years to recognize this same dodge by Ben. >>>>>>>>>>>>>

No, it is the WRONG question once you try to apply the >>>>>>>>>>>>> answer to the Halting Problem, which you do.

So the software engineering really is over your head?
I see, so like Ben you have never actually written any code. >>>>>>>>>>>

But you aren't talking about Software Engineering unless you >>>>>>>>>>> are lying about this applying to the Halting Problem
described by Linz, since that is the Halting Problem of
Computability Theory.

Of course, the likely explanation is that you are just
ignorant of what you are talking about, so you don't
understand the diference.

Ben kept masking his coding incompetence this way.
It never occurred to me that you have never written any code. >>>>>>>>>>>

I have possibly written more WORKING code than you have. >>>>>>>>>>>

I don't believe you. Your inability to answer an straight forward >>>>>>>>>> software engineering question seems to prove otherwise.

What software engineering question?

Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?

The answer to that question is NO,

Finally you admit an easily verified fact.

but that is because H doesn't, and can never do an accurarte
simulation per the definition of a UTM.

If the simulation by a UTM would be wrong then you would have to
be able
to point out the mistake in the simulation of D by H,

No, the simulation by a ACTUAL UTM will reach a final state.

I don't know why you say this when you already know that ⟨Ĥ⟩ correctly
simulated by embedded_H cannot possibly terminate normally.

Because embedded_H doesn't actually "Correctly Simulate" its input by
the definintion aquired by your mentioning of a UTM.

You have already agreed that it does simulate the first N steps
correctly. It is just as obvious that the behavior pattern of N steps of
⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly terminate normally
even if the value of N is ∞.

But N steps in not ALL steps as required by the actual definition of a UTM.

Actually N steps is the exact definition of a UTM for those N steps.
Just like with the H/D example after N steps we can see that neither
D correctly simulated by H nor ⟨Ĥ⟩ correctly simulated by embedded_H
can possibly terminate normally.

Disagreeing with easily verified facts makes you look foolish.

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

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

XPost: comp.theory, sci.logic

On 5/20/23 1:09 PM, olcott wrote:

On 5/20/2023 11:10 AM, Richard Damon wrote:

On 5/20/23 11:24 AM, olcott wrote:

On 5/20/2023 10:19 AM, Richard Damon wrote:

On 5/20/23 10:54 AM, olcott wrote:

On 5/20/2023 8:49 AM, Richard Damon wrote:

On 5/20/23 12:00 AM, olcott wrote:

On 5/19/2023 10:27 PM, Richard Damon wrote:

On 5/19/23 11:00 PM, olcott wrote:

On 5/19/2023 9:51 PM, Richard Damon wrote:

On 5/19/23 10:10 PM, olcott wrote:

On 5/19/2023 8:56 PM, Richard Damon wrote:

On 5/19/23 9:47 PM, olcott wrote:

On 5/19/2023 5:54 PM, Richard Damon wrote:

On 5/19/23 10:50 AM, olcott wrote:

Can D simulated by H terminate normally?

Wrong Question!

In other words the question is over you head.
It took me many years to recognize this same dodge by Ben. >>>>>>>>>>>>

No, it is the WRONG question once you try to apply the >>>>>>>>>>>> answer to the Halting Problem, which you do.

So the software engineering really is over your head?
I see, so like Ben you have never actually written any code. >>>>>>>>>>

But you aren't talking about Software Engineering unless you >>>>>>>>>> are lying about this applying to the Halting Problem described >>>>>>>>>> by Linz, since that is the Halting Problem of Computability >>>>>>>>>> Theory.

Of course, the likely explanation is that you are just
ignorant of what you are talking about, so you don't
understand the diference.

Ben kept masking his coding incompetence this way.
It never occurred to me that you have never written any code. >>>>>>>>>>

I have possibly written more WORKING code than you have.

I don't believe you. Your inability to answer an straight forward >>>>>>>>> software engineering question seems to prove otherwise.

What software engineering question?

Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?

The answer to that question is NO,

Finally you admit an easily verified fact.

but that is because H doesn't, and can never do an accurarte
simulation per the definition of a UTM.

If the simulation by a UTM would be wrong then you would have to be
able
to point out the mistake in the simulation of D by H,

No, the simulation by a ACTUAL UTM will reach a final state.

I don't know why you say this when you already know that ⟨Ĥ⟩ correctly >>> simulated by embedded_H cannot possibly terminate normally.

Because embedded_H doesn't actually "Correctly Simulate" its input by
the definintion aquired by your mentioning of a UTM.

You have already agreed that it does simulate the first N steps
correctly. It is just as obvious that the behavior pattern of N steps of ⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly terminate normally even if the value of N is ∞.

But N steps in not ALL steps as required by the actual definition of a UTM.

And, since H DOES abort it simulation, you need to consider that it
does, and thus it doesn't do a correct simulation, so you can't use its simuation.

You need to decide whcih fact your H implements.

Either it actually does a "Correct Simulation" and thus simulates until
it finds the actual end, which you have shown causes H to never answer, or

it aborts its simulation to give an answer, but then its simulation
doesn't meet the requirements to be "Correct", and when we put the input
that it takes into an ACTUAL UTM, we see that the actual correct
simulation of the input halts, so your H is using incorrect and unsound
logic to make its decision.

You have never answered why you think you answer is correct to say the
input isn't halting, when an actual running of the input is to see it
halts, and the actual correct simulation of the input (by an actual UTM
that doesn't abort) is to show that the correct simulation halts.

You say that the correct simulation by H is different, but you can't
show the step ACTUALLY SIMULATED that shows the actual difference. You
logic confuses the simulation of the simulator with the machine it is simulating, which are only matchable it the simulator never aborts,
which yours does.

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

XPost: comp.theory, sci.logic

On 5/20/23 2:46 PM, olcott wrote:

On 5/20/2023 1:15 PM, Richard Damon wrote:

On 5/20/23 1:09 PM, olcott wrote:

On 5/20/2023 11:10 AM, Richard Damon wrote:

On 5/20/23 11:24 AM, olcott wrote:

On 5/20/2023 10:19 AM, Richard Damon wrote:

On 5/20/23 10:54 AM, olcott wrote:

On 5/20/2023 8:49 AM, Richard Damon wrote:

On 5/20/23 12:00 AM, olcott wrote:

On 5/19/2023 10:27 PM, Richard Damon wrote:

On 5/19/23 11:00 PM, olcott wrote:

On 5/19/2023 9:51 PM, Richard Damon wrote:

On 5/19/23 10:10 PM, olcott wrote:

On 5/19/2023 8:56 PM, Richard Damon wrote:

On 5/19/23 9:47 PM, olcott wrote:

On 5/19/2023 5:54 PM, Richard Damon wrote:

On 5/19/23 10:50 AM, olcott wrote:

Can D simulated by H terminate normally?

Wrong Question!

In other words the question is over you head.
It took me many years to recognize this same dodge by Ben. >>>>>>>>>>>>>>

No, it is the WRONG question once you try to apply the >>>>>>>>>>>>>> answer to the Halting Problem, which you do.

So the software engineering really is over your head? >>>>>>>>>>>>> I see, so like Ben you have never actually written any code. >>>>>>>>>>>>

But you aren't talking about Software Engineering unless you >>>>>>>>>>>> are lying about this applying to the Halting Problem
described by Linz, since that is the Halting Problem of >>>>>>>>>>>> Computability Theory.

Of course, the likely explanation is that you are just >>>>>>>>>>>> ignorant of what you are talking about, so you don't
understand the diference.

Ben kept masking his coding incompetence this way.
It never occurred to me that you have never written any code. >>>>>>>>>>>>

I have possibly written more WORKING code than you have. >>>>>>>>>>>>

I don't believe you. Your inability to answer an straight >>>>>>>>>>> forward
software engineering question seems to prove otherwise.

What software engineering question?

Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?

The answer to that question is NO,

Finally you admit an easily verified fact.

but that is because H doesn't, and can never do an accurarte
simulation per the definition of a UTM.

If the simulation by a UTM would be wrong then you would have to >>>>>>> be able
to point out the mistake in the simulation of D by H,

No, the simulation by a ACTUAL UTM will reach a final state.

I don't know why you say this when you already know that ⟨Ĥ⟩ correctly
simulated by embedded_H cannot possibly terminate normally.

Because embedded_H doesn't actually "Correctly Simulate" its input
by the definintion aquired by your mentioning of a UTM.

You have already agreed that it does simulate the first N steps
correctly. It is just as obvious that the behavior pattern of N steps of >>> ⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly terminate normally
even if the value of N is ∞.

But N steps in not ALL steps as required by the actual definition of a
UTM.

Actually N steps is the exact definition of a UTM for those N steps.
Just like with the H/D example after N steps we can see that neither
D correctly simulated by H nor ⟨Ĥ⟩ correctly simulated by embedded_H
can possibly terminate normally.

Nope, UTMs have no concept of only doing a partial simulation.

Please show in the DEFINITON of what a UTM is that justifies your claim.

UTM isn't a "process" it is a type of Turing Machine. That machine has a defined behavior, which is a complete simulation of the input generating
the exact same results as that machine.

You are making a Type Error in your description.

Disagreeing with easily verified facts makes you look foolish.

Stating false statement shows you are a LIAR.

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

XPost: comp.theory, sci.logic

On 5/20/23 3:29 PM, olcott wrote:

On 5/20/2023 1:54 PM, Richard Damon wrote:

On 5/20/23 2:46 PM, olcott wrote:

On 5/20/2023 1:15 PM, Richard Damon wrote:

On 5/20/23 1:09 PM, olcott wrote:

On 5/20/2023 11:10 AM, Richard Damon wrote:

On 5/20/23 11:24 AM, olcott wrote:

On 5/20/2023 10:19 AM, Richard Damon wrote:

On 5/20/23 10:54 AM, olcott wrote:

On 5/20/2023 8:49 AM, Richard Damon wrote:

On 5/20/23 12:00 AM, olcott wrote:

On 5/19/2023 10:27 PM, Richard Damon wrote:

On 5/19/23 11:00 PM, olcott wrote:

On 5/19/2023 9:51 PM, Richard Damon wrote:

On 5/19/23 10:10 PM, olcott wrote:

On 5/19/2023 8:56 PM, Richard Damon wrote:

On 5/19/23 9:47 PM, olcott wrote:

On 5/19/2023 5:54 PM, Richard Damon wrote:

On 5/19/23 10:50 AM, olcott wrote:

Can D simulated by H terminate normally?

Wrong Question!

In other words the question is over you head. >>>>>>>>>>>>>>>>> It took me many years to recognize this same dodge by Ben. >>>>>>>>>>>>>>>>

No, it is the WRONG question once you try to apply the >>>>>>>>>>>>>>>> answer to the Halting Problem, which you do.

So the software engineering really is over your head? >>>>>>>>>>>>>>> I see, so like Ben you have never actually written any code. >>>>>>>>>>>>>>

But you aren't talking about Software Engineering unless >>>>>>>>>>>>>> you are lying about this applying to the Halting Problem >>>>>>>>>>>>>> described by Linz, since that is the Halting Problem of >>>>>>>>>>>>>> Computability Theory.

Of course, the likely explanation is that you are just >>>>>>>>>>>>>> ignorant of what you are talking about, so you don't >>>>>>>>>>>>>> understand the diference.

Ben kept masking his coding incompetence this way. >>>>>>>>>>>>>>> It never occurred to me that you have never written any >>>>>>>>>>>>>>> code.

I have possibly written more WORKING code than you have. >>>>>>>>>>>>>>

I don't believe you. Your inability to answer an straight >>>>>>>>>>>>> forward
software engineering question seems to prove otherwise. >>>>>>>>>>>>

What software engineering question?

Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?

The answer to that question is NO,

Finally you admit an easily verified fact.

but that is because H doesn't, and can never do an accurarte >>>>>>>>>> simulation per the definition of a UTM.

If the simulation by a UTM would be wrong then you would have >>>>>>>>> to be able
to point out the mistake in the simulation of D by H,

No, the simulation by a ACTUAL UTM will reach a final state.

I don't know why you say this when you already know that ⟨Ĥ⟩ >>>>>>> correctly
simulated by embedded_H cannot possibly terminate normally.

Because embedded_H doesn't actually "Correctly Simulate" its input >>>>>> by the definintion aquired by your mentioning of a UTM.

You have already agreed that it does simulate the first N steps
correctly. It is just as obvious that the behavior pattern of N
steps of
⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly terminate >>>>> normally
even if the value of N is ∞.

But N steps in not ALL steps as required by the actual definition of
a UTM.

Actually N steps is the exact definition of a UTM for those N steps.
Just like with the H/D example after N steps we can see that neither
D correctly simulated by H nor ⟨Ĥ⟩ correctly simulated by embedded_H >>> can possibly terminate normally.

Nope, UTMs have no concept of only doing a partial simulation.

When a simulating halt decider correctly simulates N steps of its input
it derives the exact same N steps that a pure UTM would derive because
it is itself a UTM with extra features.

Just like a racing car is a street legal care with extra features that
makes it no longer street legal.

The fact that H aborts its simulation part way means it is no longer a
UTM because it fails to meet the requriements, thus the fact that its simulation doesn't meet a final state doesn't mean the program is
non-halting.

That is like saying if you run a program for just N steps, and then stop
it and it hasn't meet a final state, that shows that the program, even
if allowed to run to completion, will never halt. That is incorrect, it
just shows that the step where it reaches its final state, if it does,
is at a step greater than N.

(a) Watching the behavior doesn't change it.
(b) Matching non-halting behavior patterns doesn't change it
(c) Even aborting the simulation after N steps doesn't change the first
N steps.

but does change the over all behavior of the machine doing it.

Since embedded_H does its analysis of its simulation presuming that the
copy of embedded_H it sees is actually a UTM, since embeded_H does abort
its simulation, and thus isn't one, means that embedded_H used a false
premise in its analysis,

Because of all this we can know that the first N steps of input D
simulated by simulating halt decider H are the actual behavior that D presents to H for these same N steps.

Right, but that doesn't give actual behavior of a CORRECT (per
definition of a UTM) simulation.

If you are saying that a simulation of N steps done correctly is your definition of a "Correct Simulation" you can't use the properties of a
UTM, since your simulation doesn't meet the requirements to be a UTM.

When we can see after N steps of correct simulation that D correctly simulated by H cannot possibly terminate normally (as you already
admitted) we can equally see after N steps of correct simulation that ⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly terminate normally.

But, since H isn't actually a UTM, that doesn't matter.

We CAN see that a UTM simulation of the input will halt becuase it will
see the first copy of embedded_H simulated will eventually abort its
simulation (making it not a UTM) and returning the INCORRECT answer of non-halting to the copy of D that called it, and that copy halting, we
see that the CORRECT simulation of the input Halts.

You really look quite foolish denying this.
It is like you agreed that 2 + 3 = 5
yet vehemently disagree that 3 + 2 = 5.

Nope, You are just lying. I never said that.

You are the one claiming that H does a correct simulation by the
requirements of a UTM, when it doesn't, so you "proof" is based on LIES,
and unsound logic.

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

XPost: comp.theory, sci.logic

On 5/20/2023 1:54 PM, Richard Damon wrote:

On 5/20/23 2:46 PM, olcott wrote:

On 5/20/2023 1:15 PM, Richard Damon wrote:

On 5/20/23 1:09 PM, olcott wrote:

On 5/20/2023 11:10 AM, Richard Damon wrote:

On 5/20/23 11:24 AM, olcott wrote:

On 5/20/2023 10:19 AM, Richard Damon wrote:

On 5/20/23 10:54 AM, olcott wrote:

On 5/20/2023 8:49 AM, Richard Damon wrote:

On 5/20/23 12:00 AM, olcott wrote:

On 5/19/2023 10:27 PM, Richard Damon wrote:

On 5/19/23 11:00 PM, olcott wrote:

On 5/19/2023 9:51 PM, Richard Damon wrote:

On 5/19/23 10:10 PM, olcott wrote:

On 5/19/2023 8:56 PM, Richard Damon wrote:

On 5/19/23 9:47 PM, olcott wrote:

On 5/19/2023 5:54 PM, Richard Damon wrote:

On 5/19/23 10:50 AM, olcott wrote:

Can D simulated by H terminate normally?

Wrong Question!

In other words the question is over you head.
It took me many years to recognize this same dodge by Ben. >>>>>>>>>>>>>>>

No, it is the WRONG question once you try to apply the >>>>>>>>>>>>>>> answer to the Halting Problem, which you do.

So the software engineering really is over your head? >>>>>>>>>>>>>> I see, so like Ben you have never actually written any code. >>>>>>>>>>>>>

But you aren't talking about Software Engineering unless >>>>>>>>>>>>> you are lying about this applying to the Halting Problem >>>>>>>>>>>>> described by Linz, since that is the Halting Problem of >>>>>>>>>>>>> Computability Theory.

Of course, the likely explanation is that you are just >>>>>>>>>>>>> ignorant of what you are talking about, so you don't >>>>>>>>>>>>> understand the diference.

Ben kept masking his coding incompetence this way. >>>>>>>>>>>>>> It never occurred to me that you have never written any code. >>>>>>>>>>>>>

I have possibly written more WORKING code than you have. >>>>>>>>>>>>>

I don't believe you. Your inability to answer an straight >>>>>>>>>>>> forward
software engineering question seems to prove otherwise. >>>>>>>>>>>

What software engineering question?

Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?

The answer to that question is NO,

Finally you admit an easily verified fact.

but that is because H doesn't, and can never do an accurarte >>>>>>>>> simulation per the definition of a UTM.

If the simulation by a UTM would be wrong then you would have to >>>>>>>> be able
to point out the mistake in the simulation of D by H,

No, the simulation by a ACTUAL UTM will reach a final state.

I don't know why you say this when you already know that ⟨Ĥ⟩
correctly
simulated by embedded_H cannot possibly terminate normally.

Because embedded_H doesn't actually "Correctly Simulate" its input
by the definintion aquired by your mentioning of a UTM.

You have already agreed that it does simulate the first N steps
correctly. It is just as obvious that the behavior pattern of N
steps of
⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly terminate
normally
even if the value of N is ∞.

But N steps in not ALL steps as required by the actual definition of
a UTM.

Actually N steps is the exact definition of a UTM for those N steps.
Just like with the H/D example after N steps we can see that neither
D correctly simulated by H nor ⟨Ĥ⟩ correctly simulated by embedded_H
can possibly terminate normally.

Nope, UTMs have no concept of only doing a partial simulation.

When a simulating halt decider correctly simulates N steps of its input
it derives the exact same N steps that a pure UTM would derive because
it is itself a UTM with extra features.

(a) Watching the behavior doesn't change it.
(b) Matching non-halting behavior patterns doesn't change it
(c) Even aborting the simulation after N steps doesn't change the first
N steps.

Because of all this we can know that the first N steps of input D
simulated by simulating halt decider H are the actual behavior that D
presents to H for these same N steps.

When we can see after N steps of correct simulation that D correctly
simulated by H cannot possibly terminate normally (as you already
admitted) we can equally see after N steps of correct simulation that
⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly terminate
normally.

You really look quite foolish denying this.
It is like you agreed that 2 + 3 = 5
yet vehemently disagree that 3 + 2 = 5.

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

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

XPost: comp.theory, sci.logic

On 5/20/2023 2:56 PM, Richard Damon wrote:

On 5/20/23 3:29 PM, olcott wrote:

On 5/20/2023 1:54 PM, Richard Damon wrote:

On 5/20/23 2:46 PM, olcott wrote:

On 5/20/2023 1:15 PM, Richard Damon wrote:

On 5/20/23 1:09 PM, olcott wrote:

On 5/20/2023 11:10 AM, Richard Damon wrote:

On 5/20/23 11:24 AM, olcott wrote:

On 5/20/2023 10:19 AM, Richard Damon wrote:

On 5/20/23 10:54 AM, olcott wrote:

On 5/20/2023 8:49 AM, Richard Damon wrote:

On 5/20/23 12:00 AM, olcott wrote:

On 5/19/2023 10:27 PM, Richard Damon wrote:

On 5/19/23 11:00 PM, olcott wrote:

On 5/19/2023 9:51 PM, Richard Damon wrote:

On 5/19/23 10:10 PM, olcott wrote:

On 5/19/2023 8:56 PM, Richard Damon wrote:

On 5/19/23 9:47 PM, olcott wrote:

On 5/19/2023 5:54 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, olcott wrote:

Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>

Wrong Question!

In other words the question is over you head. >>>>>>>>>>>>>>>>>> It took me many years to recognize this same dodge by >>>>>>>>>>>>>>>>>> Ben.

No, it is the WRONG question once you try to apply the >>>>>>>>>>>>>>>>> answer to the Halting Problem, which you do. >>>>>>>>>>>>>>>>>

So the software engineering really is over your head? >>>>>>>>>>>>>>>> I see, so like Ben you have never actually written any >>>>>>>>>>>>>>>> code.

But you aren't talking about Software Engineering unless >>>>>>>>>>>>>>> you are lying about this applying to the Halting Problem >>>>>>>>>>>>>>> described by Linz, since that is the Halting Problem of >>>>>>>>>>>>>>> Computability Theory.

Of course, the likely explanation is that you are just >>>>>>>>>>>>>>> ignorant of what you are talking about, so you don't >>>>>>>>>>>>>>> understand the diference.

Ben kept masking his coding incompetence this way. >>>>>>>>>>>>>>>> It never occurred to me that you have never written any >>>>>>>>>>>>>>>> code.

I have possibly written more WORKING code than you have. >>>>>>>>>>>>>>>

I don't believe you. Your inability to answer an straight >>>>>>>>>>>>>> forward
software engineering question seems to prove otherwise. >>>>>>>>>>>>>

What software engineering question?

Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?

The answer to that question is NO,

Finally you admit an easily verified fact.

but that is because H doesn't, and can never do an accurarte >>>>>>>>>>> simulation per the definition of a UTM.

If the simulation by a UTM would be wrong then you would have >>>>>>>>>> to be able
to point out the mistake in the simulation of D by H,

No, the simulation by a ACTUAL UTM will reach a final state. >>>>>>>>>

I don't know why you say this when you already know that ⟨Ĥ⟩ >>>>>>>> correctly
simulated by embedded_H cannot possibly terminate normally.

Because embedded_H doesn't actually "Correctly Simulate" its
input by the definintion aquired by your mentioning of a UTM.

You have already agreed that it does simulate the first N steps
correctly. It is just as obvious that the behavior pattern of N
steps of
⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly terminate >>>>>> normally
even if the value of N is ∞.

But N steps in not ALL steps as required by the actual definition
of a UTM.

Actually N steps is the exact definition of a UTM for those N steps.
Just like with the H/D example after N steps we can see that neither
D correctly simulated by H nor ⟨Ĥ⟩ correctly simulated by embedded_H >>>> can possibly terminate normally.

Nope, UTMs have no concept of only doing a partial simulation.

When a simulating halt decider correctly simulates N steps of its input
it derives the exact same N steps that a pure UTM would derive because
it is itself a UTM with extra features.

Just like a racing car is a street legal care with extra features that
makes it no longer street legal.

The fact that H aborts its simulation part way means it is no longer a
UTM

*Yet only at the point where it aborts its simulation*
At this point where it aborts its simulation we can see that it must
do this to prevent its own infinite execution, thus conclusively proving
that it correctly determined that its simulated input cannot possibly
terminate normally.

How much longer are you going to play the fool and deny this?

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

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

XPost: comp.theory, sci.logic

On 5/20/23 4:33 PM, olcott wrote:

On 5/20/2023 2:56 PM, Richard Damon wrote:

On 5/20/23 3:29 PM, olcott wrote:

On 5/20/2023 1:54 PM, Richard Damon wrote:

On 5/20/23 2:46 PM, olcott wrote:

On 5/20/2023 1:15 PM, Richard Damon wrote:

On 5/20/23 1:09 PM, olcott wrote:

On 5/20/2023 11:10 AM, Richard Damon wrote:

On 5/20/23 11:24 AM, olcott wrote:

On 5/20/2023 10:19 AM, Richard Damon wrote:

On 5/20/23 10:54 AM, olcott wrote:

On 5/20/2023 8:49 AM, Richard Damon wrote:

On 5/20/23 12:00 AM, olcott wrote:

On 5/19/2023 10:27 PM, Richard Damon wrote:

On 5/19/23 11:00 PM, olcott wrote:

On 5/19/2023 9:51 PM, Richard Damon wrote:

On 5/19/23 10:10 PM, olcott wrote:

On 5/19/2023 8:56 PM, Richard Damon wrote:

On 5/19/23 9:47 PM, olcott wrote:

On 5/19/2023 5:54 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, olcott wrote:

Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>

Wrong Question!

In other words the question is over you head. >>>>>>>>>>>>>>>>>>> It took me many years to recognize this same dodge by >>>>>>>>>>>>>>>>>>> Ben.

No, it is the WRONG question once you try to apply the >>>>>>>>>>>>>>>>>> answer to the Halting Problem, which you do. >>>>>>>>>>>>>>>>>>

So the software engineering really is over your head? >>>>>>>>>>>>>>>>> I see, so like Ben you have never actually written any >>>>>>>>>>>>>>>>> code.

But you aren't talking about Software Engineering unless >>>>>>>>>>>>>>>> you are lying about this applying to the Halting Problem >>>>>>>>>>>>>>>> described by Linz, since that is the Halting Problem of >>>>>>>>>>>>>>>> Computability Theory.

Of course, the likely explanation is that you are just >>>>>>>>>>>>>>>> ignorant of what you are talking about, so you don't >>>>>>>>>>>>>>>> understand the diference.

Ben kept masking his coding incompetence this way. >>>>>>>>>>>>>>>>> It never occurred to me that you have never written any >>>>>>>>>>>>>>>>> code.

I have possibly written more WORKING code than you have. >>>>>>>>>>>>>>>>

I don't believe you. Your inability to answer an straight >>>>>>>>>>>>>>> forward
software engineering question seems to prove otherwise. >>>>>>>>>>>>>>

What software engineering question?

Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?

The answer to that question is NO,

Finally you admit an easily verified fact.

but that is because H doesn't, and can never do an accurarte >>>>>>>>>>>> simulation per the definition of a UTM.

If the simulation by a UTM would be wrong then you would have >>>>>>>>>>> to be able
to point out the mistake in the simulation of D by H,

No, the simulation by a ACTUAL UTM will reach a final state. >>>>>>>>>>

I don't know why you say this when you already know that ⟨Ĥ⟩ >>>>>>>>> correctly
simulated by embedded_H cannot possibly terminate normally.

Because embedded_H doesn't actually "Correctly Simulate" its
input by the definintion aquired by your mentioning of a UTM.

You have already agreed that it does simulate the first N steps
correctly. It is just as obvious that the behavior pattern of N
steps of
⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly terminate >>>>>>> normally
even if the value of N is ∞.

But N steps in not ALL steps as required by the actual definition
of a UTM.

Actually N steps is the exact definition of a UTM for those N steps. >>>>> Just like with the H/D example after N steps we can see that neither >>>>> D correctly simulated by H nor ⟨Ĥ⟩ correctly simulated by embedded_H >>>>> can possibly terminate normally.

Nope, UTMs have no concept of only doing a partial simulation.

When a simulating halt decider correctly simulates N steps of its input
it derives the exact same N steps that a pure UTM would derive because
it is itself a UTM with extra features.

Just like a racing car is a street legal care with extra features that
makes it no longer street legal.

The fact that H aborts its simulation part way means it is no longer a
UTM

*Yet only at the point where it aborts its simulation*

Right, but that affect the behavior of ALL copies of it, since they all
act the same.

Do you think you are immortal because you haven't died yet, and that
everyone is immortal until the point in time they die?

Since it just proves it isn't a UTM, it can't assume that the copy it is simulating is, it needs to account for that behavior.

The fact that the DESIGN logic to do this goes into an infinite loop,
doesn't mean that the program itself does.

Since H aborts its simulation and returns 0, its input will see its copy
do exactly the same thing and thus will Halt, making the answer wrong.

Since H isn't a UTM, since if fails to meet the defintion, the fact that
it can't reach a final state is irrelevent, as is any definiton of
"Correct Simulation" that differs from what a UTM does.

UTM(D,D) Halts, therefore the CORRECT SIMULATION (by a UTM which is what
is allowed to replace the actual behavior of the machine) Halts, and
thus the CORRECT answer is Halting.

You are just showing that you have fallen for your own Strawman
Deception that got you to use the wrong criteria.

At this point where it aborts its simulation we can see that it must
do this to prevent its own infinite execution, thus conclusively proving
that it correctly determined that its simulated input cannot possibly terminate normally.

How much longer are you going to play the fool and deny this?

No, it does so because it has been programmed to do so, and thus ALL
copies of it will do so.

It makes the error assuming that the copy it is simulating will do
something different than it does.

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

XPost: comp.theory, sci.logic

On 5/20/2023 3:48 PM, Richard Damon wrote:

On 5/20/23 4:33 PM, olcott wrote:

On 5/20/2023 2:56 PM, Richard Damon wrote:

On 5/20/23 3:29 PM, olcott wrote:

On 5/20/2023 1:54 PM, Richard Damon wrote:

On 5/20/23 2:46 PM, olcott wrote:

On 5/20/2023 1:15 PM, Richard Damon wrote:

On 5/20/23 1:09 PM, olcott wrote:

On 5/20/2023 11:10 AM, Richard Damon wrote:

On 5/20/23 11:24 AM, olcott wrote:

On 5/20/2023 10:19 AM, Richard Damon wrote:

On 5/20/23 10:54 AM, olcott wrote:

On 5/20/2023 8:49 AM, Richard Damon wrote:

On 5/20/23 12:00 AM, olcott wrote:

On 5/19/2023 10:27 PM, Richard Damon wrote:

On 5/19/23 11:00 PM, olcott wrote:

On 5/19/2023 9:51 PM, Richard Damon wrote:

On 5/19/23 10:10 PM, olcott wrote:

On 5/19/2023 8:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, olcott wrote:

On 5/19/2023 5:54 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, olcott wrote:

Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>

Wrong Question!

In other words the question is over you head. >>>>>>>>>>>>>>>>>>>> It took me many years to recognize this same dodge >>>>>>>>>>>>>>>>>>>> by Ben.

No, it is the WRONG question once you try to apply >>>>>>>>>>>>>>>>>>> the answer to the Halting Problem, which you do. >>>>>>>>>>>>>>>>>>>

So the software engineering really is over your head? >>>>>>>>>>>>>>>>>> I see, so like Ben you have never actually written any >>>>>>>>>>>>>>>>>> code.

But you aren't talking about Software Engineering >>>>>>>>>>>>>>>>> unless you are lying about this applying to the Halting >>>>>>>>>>>>>>>>> Problem described by Linz, since that is the Halting >>>>>>>>>>>>>>>>> Problem of Computability Theory.

Of course, the likely explanation is that you are just >>>>>>>>>>>>>>>>> ignorant of what you are talking about, so you don't >>>>>>>>>>>>>>>>> understand the diference.

Ben kept masking his coding incompetence this way. >>>>>>>>>>>>>>>>>> It never occurred to me that you have never written >>>>>>>>>>>>>>>>>> any code.

I have possibly written more WORKING code than you have. >>>>>>>>>>>>>>>>>

I don't believe you. Your inability to answer an >>>>>>>>>>>>>>>> straight forward
software engineering question seems to prove otherwise. >>>>>>>>>>>>>>>

What software engineering question?

Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?

The answer to that question is NO,

Finally you admit an easily verified fact.

but that is because H doesn't, and can never do an
accurarte simulation per the definition of a UTM.

If the simulation by a UTM would be wrong then you would >>>>>>>>>>>> have to be able
to point out the mistake in the simulation of D by H,

No, the simulation by a ACTUAL UTM will reach a final state. >>>>>>>>>>>

I don't know why you say this when you already know that ⟨Ĥ⟩ >>>>>>>>>> correctly
simulated by embedded_H cannot possibly terminate normally. >>>>>>>>>

Because embedded_H doesn't actually "Correctly Simulate" its >>>>>>>>> input by the definintion aquired by your mentioning of a UTM. >>>>>>>>>

You have already agreed that it does simulate the first N steps >>>>>>>> correctly. It is just as obvious that the behavior pattern of N >>>>>>>> steps of
⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly terminate >>>>>>>> normally
even if the value of N is ∞.

But N steps in not ALL steps as required by the actual definition >>>>>>> of a UTM.

Actually N steps is the exact definition of a UTM for those N steps. >>>>>> Just like with the H/D example after N steps we can see that neither >>>>>> D correctly simulated by H nor ⟨Ĥ⟩ correctly simulated by embedded_H
can possibly terminate normally.

Nope, UTMs have no concept of only doing a partial simulation.

When a simulating halt decider correctly simulates N steps of its input >>>> it derives the exact same N steps that a pure UTM would derive because >>>> it is itself a UTM with extra features.

Just like a racing car is a street legal care with extra features
that makes it no longer street legal.

The fact that H aborts its simulation part way means it is no longer
a UTM

*Yet only at the point where it aborts its simulation*

Right, but that affect the behavior of ALL copies of it, since they all
act the same.

Do you think you are immortal because you haven't died yet, and that
everyone is immortal until the point in time they die?

Since it just proves it isn't a UTM, it can't assume that the copy it is simulating is, it needs to account for that behavior.

The fact that the DESIGN logic to do this goes into an infinite loop,
doesn't mean that the program itself does.

Since H aborts its simulation and returns 0, its input will see its copy
do exactly the same thing and thus will Halt, making the answer wrong.

Since H isn't a UTM, since if fails to meet the defintion, the fact that
it can't reach a final state is irrelevent, as is any definiton of
"Correct Simulation" that differs from what a UTM does.

UTM(D,D) Halts, therefore the CORRECT SIMULATION (by a UTM which is what
is allowed to replace the actual behavior of the machine) Halts, and
thus the CORRECT answer is Halting.

You are just showing that you have fallen for your own Strawman
Deception that got you to use the wrong criteria.

At this point where it aborts its simulation we can see that it must
do this to prevent its own infinite execution, thus conclusively proving
that it correctly determined that its simulated input cannot possibly
terminate normally.

How much longer are you going to play the fool and deny this?

No, it does so because it has been programmed to do so, and thus ALL
copies of it will do so.

It makes the error assuming that the copy it is simulating will do
something different than it does.

It makes no error. As you already admitted D correctly simulated by H
cannot possibly terminate normally thus its isomorphism of ⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly terminate normally.

Are you going to keep playing the fool on this?

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

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

XPost: comp.theory, sci.logic

On 5/20/23 5:10 PM, olcott wrote:

On 5/20/2023 3:48 PM, Richard Damon wrote:

On 5/20/23 4:33 PM, olcott wrote:

On 5/20/2023 2:56 PM, Richard Damon wrote:

On 5/20/23 3:29 PM, olcott wrote:

On 5/20/2023 1:54 PM, Richard Damon wrote:

On 5/20/23 2:46 PM, olcott wrote:

On 5/20/2023 1:15 PM, Richard Damon wrote:

On 5/20/23 1:09 PM, olcott wrote:

On 5/20/2023 11:10 AM, Richard Damon wrote:

On 5/20/23 11:24 AM, olcott wrote:

On 5/20/2023 10:19 AM, Richard Damon wrote:

On 5/20/23 10:54 AM, olcott wrote:

On 5/20/2023 8:49 AM, Richard Damon wrote:

On 5/20/23 12:00 AM, olcott wrote:

On 5/19/2023 10:27 PM, Richard Damon wrote:

On 5/19/23 11:00 PM, olcott wrote:

On 5/19/2023 9:51 PM, Richard Damon wrote:

On 5/19/23 10:10 PM, olcott wrote:

On 5/19/2023 8:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, olcott wrote:

On 5/19/2023 5:54 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>

Wrong Question!

In other words the question is over you head. >>>>>>>>>>>>>>>>>>>>> It took me many years to recognize this same dodge >>>>>>>>>>>>>>>>>>>>> by Ben.

No, it is the WRONG question once you try to apply >>>>>>>>>>>>>>>>>>>> the answer to the Halting Problem, which you do. >>>>>>>>>>>>>>>>>>>>

So the software engineering really is over your head? >>>>>>>>>>>>>>>>>>> I see, so like Ben you have never actually written >>>>>>>>>>>>>>>>>>> any code.

But you aren't talking about Software Engineering >>>>>>>>>>>>>>>>>> unless you are lying about this applying to the >>>>>>>>>>>>>>>>>> Halting Problem described by Linz, since that is the >>>>>>>>>>>>>>>>>> Halting Problem of Computability Theory.

Of course, the likely explanation is that you are just >>>>>>>>>>>>>>>>>> ignorant of what you are talking about, so you don't >>>>>>>>>>>>>>>>>> understand the diference.

Ben kept masking his coding incompetence this way. >>>>>>>>>>>>>>>>>>> It never occurred to me that you have never written >>>>>>>>>>>>>>>>>>> any code.

I have possibly written more WORKING code than you have. >>>>>>>>>>>>>>>>>>

I don't believe you. Your inability to answer an >>>>>>>>>>>>>>>>> straight forward
software engineering question seems to prove otherwise. >>>>>>>>>>>>>>>>

What software engineering question?

Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?

The answer to that question is NO,

Finally you admit an easily verified fact.

but that is because H doesn't, and can never do an >>>>>>>>>>>>>> accurarte simulation per the definition of a UTM.

If the simulation by a UTM would be wrong then you would >>>>>>>>>>>>> have to be able
to point out the mistake in the simulation of D by H, >>>>>>>>>>>>

No, the simulation by a ACTUAL UTM will reach a final state. >>>>>>>>>>>>

I don't know why you say this when you already know that ⟨Ĥ⟩ >>>>>>>>>>> correctly
simulated by embedded_H cannot possibly terminate normally. >>>>>>>>>>

Because embedded_H doesn't actually "Correctly Simulate" its >>>>>>>>>> input by the definintion aquired by your mentioning of a UTM. >>>>>>>>>>

You have already agreed that it does simulate the first N steps >>>>>>>>> correctly. It is just as obvious that the behavior pattern of N >>>>>>>>> steps of
⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly terminate >>>>>>>>> normally
even if the value of N is ∞.

But N steps in not ALL steps as required by the actual
definition of a UTM.

Actually N steps is the exact definition of a UTM for those N steps. >>>>>>> Just like with the H/D example after N steps we can see that neither >>>>>>> D correctly simulated by H nor ⟨Ĥ⟩ correctly simulated by embedded_H
can possibly terminate normally.

Nope, UTMs have no concept of only doing a partial simulation.

When a simulating halt decider correctly simulates N steps of its
input
it derives the exact same N steps that a pure UTM would derive because >>>>> it is itself a UTM with extra features.

Just like a racing car is a street legal care with extra features
that makes it no longer street legal.

The fact that H aborts its simulation part way means it is no longer
a UTM

*Yet only at the point where it aborts its simulation*

Right, but that affect the behavior of ALL copies of it, since they
all act the same.

Do you think you are immortal because you haven't died yet, and that
everyone is immortal until the point in time they die?

Since it just proves it isn't a UTM, it can't assume that the copy it
is simulating is, it needs to account for that behavior.

The fact that the DESIGN logic to do this goes into an infinite loop,
doesn't mean that the program itself does.

Since H aborts its simulation and returns 0, its input will see its
copy do exactly the same thing and thus will Halt, making the answer
wrong.

Since H isn't a UTM, since if fails to meet the defintion, the fact
that it can't reach a final state is irrelevent, as is any definiton
of "Correct Simulation" that differs from what a UTM does.

UTM(D,D) Halts, therefore the CORRECT SIMULATION (by a UTM which is
what is allowed to replace the actual behavior of the machine) Halts,
and thus the CORRECT answer is Halting.

You are just showing that you have fallen for your own Strawman
Deception that got you to use the wrong criteria.

At this point where it aborts its simulation we can see that it must
do this to prevent its own infinite execution, thus conclusively proving >>> that it correctly determined that its simulated input cannot possibly
terminate normally.

How much longer are you going to play the fool and deny this?

No, it does so because it has been programmed to do so, and thus ALL
copies of it will do so.

It makes the error assuming that the copy it is simulating will do
something different than it does.

It makes no error. As you already admitted D correctly simulated by H
cannot possibly terminate normally thus its isomorphism of ⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly terminate normally.

Are you going to keep playing the fool on this?

Except that you are answering the wrong question.

The question is NOT "Can H simulate its input to a fina state?" but is
"Does the input represent a Halting Computation?", which can be also
expressed as "does a UTM simulating the input to H halt?", but that is
only because BY DEFIHNITION, a UTM simulating a representation will
exactly reproduce the behavior of the machine that input represents.

If H wants to be a UTM, then it can't stop and give an answer if its
input isn't halting, and thus it will fail to be a Halt Decider.

Unless you think that "Saying the input is non-halting" is exactly the
same thing a "Being Non-Halting" you answer is wrong.

Saying it is would be like saying that a sign with the word "Blue" in
Red letters is a sign whose color is blue.

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

XPost: comp.theory, sci.logic

On 5/20/2023 4:24 PM, Richard Damon wrote:

On 5/20/23 5:10 PM, olcott wrote:

On 5/20/2023 3:48 PM, Richard Damon wrote:

On 5/20/23 4:33 PM, olcott wrote:

On 5/20/2023 2:56 PM, Richard Damon wrote:

On 5/20/23 3:29 PM, olcott wrote:

On 5/20/2023 1:54 PM, Richard Damon wrote:

On 5/20/23 2:46 PM, olcott wrote:

On 5/20/2023 1:15 PM, Richard Damon wrote:

On 5/20/23 1:09 PM, olcott wrote:

On 5/20/2023 11:10 AM, Richard Damon wrote:

On 5/20/23 11:24 AM, olcott wrote:

On 5/20/2023 10:19 AM, Richard Damon wrote:

On 5/20/23 10:54 AM, olcott wrote:

On 5/20/2023 8:49 AM, Richard Damon wrote:

On 5/20/23 12:00 AM, olcott wrote:

On 5/19/2023 10:27 PM, Richard Damon wrote:

On 5/19/23 11:00 PM, olcott wrote:

On 5/19/2023 9:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, olcott wrote:

On 5/19/2023 8:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, olcott wrote:

On 5/19/2023 5:54 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>

Wrong Question!

In other words the question is over you head. >>>>>>>>>>>>>>>>>>>>>> It took me many years to recognize this same dodge >>>>>>>>>>>>>>>>>>>>>> by Ben.

No, it is the WRONG question once you try to apply >>>>>>>>>>>>>>>>>>>>> the answer to the Halting Problem, which you do. >>>>>>>>>>>>>>>>>>>>>

So the software engineering really is over your head? >>>>>>>>>>>>>>>>>>>> I see, so like Ben you have never actually written >>>>>>>>>>>>>>>>>>>> any code.

But you aren't talking about Software Engineering >>>>>>>>>>>>>>>>>>> unless you are lying about this applying to the >>>>>>>>>>>>>>>>>>> Halting Problem described by Linz, since that is the >>>>>>>>>>>>>>>>>>> Halting Problem of Computability Theory. >>>>>>>>>>>>>>>>>>>
Of course, the likely explanation is that you are >>>>>>>>>>>>>>>>>>> just ignorant of what you are talking about, so you >>>>>>>>>>>>>>>>>>> don't understand the diference.

Ben kept masking his coding incompetence this way. >>>>>>>>>>>>>>>>>>>> It never occurred to me that you have never written >>>>>>>>>>>>>>>>>>>> any code.

I have possibly written more WORKING code than you have. >>>>>>>>>>>>>>>>>>>

I don't believe you. Your inability to answer an >>>>>>>>>>>>>>>>>> straight forward
software engineering question seems to prove otherwise. >>>>>>>>>>>>>>>>>

What software engineering question?

Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?

The answer to that question is NO,

Finally you admit an easily verified fact.

but that is because H doesn't, and can never do an >>>>>>>>>>>>>>> accurarte simulation per the definition of a UTM. >>>>>>>>>>>>>>>

If the simulation by a UTM would be wrong then you would >>>>>>>>>>>>>> have to be able
to point out the mistake in the simulation of D by H, >>>>>>>>>>>>>

No, the simulation by a ACTUAL UTM will reach a final state. >>>>>>>>>>>>>

I don't know why you say this when you already know that ⟨Ĥ⟩ >>>>>>>>>>>> correctly
simulated by embedded_H cannot possibly terminate normally. >>>>>>>>>>>

Because embedded_H doesn't actually "Correctly Simulate" its >>>>>>>>>>> input by the definintion aquired by your mentioning of a UTM. >>>>>>>>>>>

You have already agreed that it does simulate the first N steps >>>>>>>>>> correctly. It is just as obvious that the behavior pattern of >>>>>>>>>> N steps of
⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly >>>>>>>>>> terminate normally
even if the value of N is ∞.

But N steps in not ALL steps as required by the actual
definition of a UTM.

Actually N steps is the exact definition of a UTM for those N
steps.
Just like with the H/D example after N steps we can see that
neither
D correctly simulated by H nor ⟨Ĥ⟩ correctly simulated by >>>>>>>> embedded_H
can possibly terminate normally.

Nope, UTMs have no concept of only doing a partial simulation.

When a simulating halt decider correctly simulates N steps of its
input
it derives the exact same N steps that a pure UTM would derive
because
it is itself a UTM with extra features.

Just like a racing car is a street legal care with extra features
that makes it no longer street legal.

The fact that H aborts its simulation part way means it is no
longer a UTM

*Yet only at the point where it aborts its simulation*

Right, but that affect the behavior of ALL copies of it, since they
all act the same.

Do you think you are immortal because you haven't died yet, and that
everyone is immortal until the point in time they die?

Since it just proves it isn't a UTM, it can't assume that the copy it
is simulating is, it needs to account for that behavior.

The fact that the DESIGN logic to do this goes into an infinite loop,
doesn't mean that the program itself does.

Since H aborts its simulation and returns 0, its input will see its
copy do exactly the same thing and thus will Halt, making the answer
wrong.

Since H isn't a UTM, since if fails to meet the defintion, the fact
that it can't reach a final state is irrelevent, as is any definiton
of "Correct Simulation" that differs from what a UTM does.

UTM(D,D) Halts, therefore the CORRECT SIMULATION (by a UTM which is
what is allowed to replace the actual behavior of the machine) Halts,
and thus the CORRECT answer is Halting.

You are just showing that you have fallen for your own Strawman
Deception that got you to use the wrong criteria.

At this point where it aborts its simulation we can see that it must
do this to prevent its own infinite execution, thus conclusively
proving
that it correctly determined that its simulated input cannot possibly
terminate normally.

How much longer are you going to play the fool and deny this?

No, it does so because it has been programmed to do so, and thus ALL
copies of it will do so.

It makes the error assuming that the copy it is simulating will do
something different than it does.

It makes no error. As you already admitted D correctly simulated by H
cannot possibly terminate normally thus its isomorphism of ⟨Ĥ⟩ correctly
simulated by embedded_H cannot possibly terminate normally.

Are you going to keep playing the fool on this?

Except that you are answering the wrong question.

In other words you want to keep playing the fool and dodging the actual question that I am actually asking.

So you agreed that D correctly simulated H cannot possibly terminate
normally and the exact same thing goes for ⟨Ĥ⟩ correctly simulated by embedded_H.

Most novices dealing with the halting problem fail to understand that
halting <is> terminating normally and terminating for any other reason
is not halting.


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

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

XPost: comp.theory, sci.logic

Child molester Peter Oolcott wrote:
...

Most novices dealing with the halting problem fail to understand that
halting <is> terminating normally and terminating for any other reason
is not halting.

Come on! In practice halting or terminating, in any way, for a real
program is just the states of a bunch of switches that happens to be a computer because we interpret the states. No difference.

Give up CS, Peter, its not your thing. Or persist, meanwhile, at least,
you're not molesting children.

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

XPost: comp.theory, sci.logic

On 5/20/23 5:29 PM, olcott wrote:

On 5/20/2023 4:24 PM, Richard Damon wrote:

On 5/20/23 5:10 PM, olcott wrote:

On 5/20/2023 3:48 PM, Richard Damon wrote:

On 5/20/23 4:33 PM, olcott wrote:

On 5/20/2023 2:56 PM, Richard Damon wrote:

On 5/20/23 3:29 PM, olcott wrote:

On 5/20/2023 1:54 PM, Richard Damon wrote:

On 5/20/23 2:46 PM, olcott wrote:

On 5/20/2023 1:15 PM, Richard Damon wrote:

On 5/20/23 1:09 PM, olcott wrote:

On 5/20/2023 11:10 AM, Richard Damon wrote:

On 5/20/23 11:24 AM, olcott wrote:

On 5/20/2023 10:19 AM, Richard Damon wrote:

On 5/20/23 10:54 AM, olcott wrote:

On 5/20/2023 8:49 AM, Richard Damon wrote:

On 5/20/23 12:00 AM, olcott wrote:

On 5/19/2023 10:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 5/19/23 11:00 PM, olcott wrote:

On 5/19/2023 9:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, olcott wrote:

On 5/19/2023 8:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>

Wrong Question!

In other words the question is over you head. >>>>>>>>>>>>>>>>>>>>>>> It took me many years to recognize this same >>>>>>>>>>>>>>>>>>>>>>> dodge by Ben.

No, it is the WRONG question once you try to apply >>>>>>>>>>>>>>>>>>>>>> the answer to the Halting Problem, which you do. >>>>>>>>>>>>>>>>>>>>>>

So the software engineering really is over your head? >>>>>>>>>>>>>>>>>>>>> I see, so like Ben you have never actually written >>>>>>>>>>>>>>>>>>>>> any code.

But you aren't talking about Software Engineering >>>>>>>>>>>>>>>>>>>> unless you are lying about this applying to the >>>>>>>>>>>>>>>>>>>> Halting Problem described by Linz, since that is the >>>>>>>>>>>>>>>>>>>> Halting Problem of Computability Theory. >>>>>>>>>>>>>>>>>>>>
Of course, the likely explanation is that you are >>>>>>>>>>>>>>>>>>>> just ignorant of what you are talking about, so you >>>>>>>>>>>>>>>>>>>> don't understand the diference.

Ben kept masking his coding incompetence this way. >>>>>>>>>>>>>>>>>>>>> It never occurred to me that you have never written >>>>>>>>>>>>>>>>>>>>> any code.

I have possibly written more WORKING code than you >>>>>>>>>>>>>>>>>>>> have.

I don't believe you. Your inability to answer an >>>>>>>>>>>>>>>>>>> straight forward
software engineering question seems to prove otherwise. >>>>>>>>>>>>>>>>>>

What software engineering question?

Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?

The answer to that question is NO,

Finally you admit an easily verified fact.

but that is because H doesn't, and can never do an >>>>>>>>>>>>>>>> accurarte simulation per the definition of a UTM. >>>>>>>>>>>>>>>>

If the simulation by a UTM would be wrong then you would >>>>>>>>>>>>>>> have to be able
to point out the mistake in the simulation of D by H, >>>>>>>>>>>>>>

No, the simulation by a ACTUAL UTM will reach a final state. >>>>>>>>>>>>>>

I don't know why you say this when you already know that >>>>>>>>>>>>> ⟨Ĥ⟩ correctly
simulated by embedded_H cannot possibly terminate normally. >>>>>>>>>>>>

Because embedded_H doesn't actually "Correctly Simulate" its >>>>>>>>>>>> input by the definintion aquired by your mentioning of a UTM. >>>>>>>>>>>>

You have already agreed that it does simulate the first N steps >>>>>>>>>>> correctly. It is just as obvious that the behavior pattern of >>>>>>>>>>> N steps of
⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly >>>>>>>>>>> terminate normally
even if the value of N is ∞.

But N steps in not ALL steps as required by the actual
definition of a UTM.

Actually N steps is the exact definition of a UTM for those N >>>>>>>>> steps.
Just like with the H/D example after N steps we can see that >>>>>>>>> neither
D correctly simulated by H nor ⟨Ĥ⟩ correctly simulated by >>>>>>>>> embedded_H
can possibly terminate normally.

Nope, UTMs have no concept of only doing a partial simulation. >>>>>>>>

When a simulating halt decider correctly simulates N steps of its >>>>>>> input
it derives the exact same N steps that a pure UTM would derive
because
it is itself a UTM with extra features.

Just like a racing car is a street legal care with extra features
that makes it no longer street legal.

The fact that H aborts its simulation part way means it is no
longer a UTM

*Yet only at the point where it aborts its simulation*

Right, but that affect the behavior of ALL copies of it, since they
all act the same.

Do you think you are immortal because you haven't died yet, and that
everyone is immortal until the point in time they die?

Since it just proves it isn't a UTM, it can't assume that the copy
it is simulating is, it needs to account for that behavior.

The fact that the DESIGN logic to do this goes into an infinite
loop, doesn't mean that the program itself does.

Since H aborts its simulation and returns 0, its input will see its
copy do exactly the same thing and thus will Halt, making the answer
wrong.

Since H isn't a UTM, since if fails to meet the defintion, the fact
that it can't reach a final state is irrelevent, as is any definiton
of "Correct Simulation" that differs from what a UTM does.

UTM(D,D) Halts, therefore the CORRECT SIMULATION (by a UTM which is
what is allowed to replace the actual behavior of the machine)
Halts, and thus the CORRECT answer is Halting.

You are just showing that you have fallen for your own Strawman
Deception that got you to use the wrong criteria.

At this point where it aborts its simulation we can see that it must >>>>> do this to prevent its own infinite execution, thus conclusively
proving
that it correctly determined that its simulated input cannot possibly >>>>> terminate normally.

How much longer are you going to play the fool and deny this?

No, it does so because it has been programmed to do so, and thus ALL
copies of it will do so.

It makes the error assuming that the copy it is simulating will do
something different than it does.

It makes no error. As you already admitted D correctly simulated by H
cannot possibly terminate normally thus its isomorphism of ⟨Ĥ⟩ correctly
simulated by embedded_H cannot possibly terminate normally.

Are you going to keep playing the fool on this?

Except that you are answering the wrong question.

In other words you want to keep playing the fool and dodging the actual question that I am actually asking.

No, you are showing yourself to be the fool by not understand your own stupidity.

So you agreed that D correctly simulated H cannot possibly terminate
normally and the exact same thing goes for ⟨Ĥ⟩ correctly simulated by embedded_H.

No, I am saying that H can not correctly simulate the input H and give
an answer. If H DOES try to correctly simulate its input, then it can
never giv an answer. if it stops simulating to give an answer, it did
not correctly simulate its input, per the required definition from a UTM.

You just don't understand what a UTM actually is and what its correct simulation imply.

Most novices dealing with the halting problem fail to understand that
halting <is> terminating normally and terminating for any other reason
is not halting.

Right, terminating normally of the ACTUAL MACHINE, which will not stop
for any reason other than reaching the final state, so there are no
other possible reasons for an actual Turing Machine to stop.

You can not "stop" an actual Turing Machine, it WILL just run to
completion. Yes, you can stop a simulation of a Turing Machine, but that
just means you don't have any direct proof of the machines actual
behavior. You seem to not understand the fundamentals of what Turing
Machines are.

Your arguement is basically like you got on a highway and started to
drive on it. You then go off the highway at an exit. Since you never
reached the end of the Highway, you can concludee the Highway has no end.

FAIL.

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

XPost: comp.theory, sci.logic

On 5/20/2023 6:52 PM, Richard Damon wrote:

On 5/20/23 5:29 PM, olcott wrote:

On 5/20/2023 4:24 PM, Richard Damon wrote:

On 5/20/23 5:10 PM, olcott wrote:

On 5/20/2023 3:48 PM, Richard Damon wrote:

On 5/20/23 4:33 PM, olcott wrote:

On 5/20/2023 2:56 PM, Richard Damon wrote:

On 5/20/23 3:29 PM, olcott wrote:

On 5/20/2023 1:54 PM, Richard Damon wrote:

On 5/20/23 2:46 PM, olcott wrote:

On 5/20/2023 1:15 PM, Richard Damon wrote:

On 5/20/23 1:09 PM, olcott wrote:

On 5/20/2023 11:10 AM, Richard Damon wrote:

On 5/20/23 11:24 AM, olcott wrote:

On 5/20/2023 10:19 AM, Richard Damon wrote:

On 5/20/23 10:54 AM, olcott wrote:

On 5/20/2023 8:49 AM, Richard Damon wrote:

On 5/20/23 12:00 AM, olcott wrote:

On 5/19/2023 10:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 5/19/23 11:00 PM, olcott wrote:

On 5/19/2023 9:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, olcott wrote:

On 5/19/2023 8:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>

Wrong Question!

In other words the question is over you head. >>>>>>>>>>>>>>>>>>>>>>>> It took me many years to recognize this same >>>>>>>>>>>>>>>>>>>>>>>> dodge by Ben.

No, it is the WRONG question once you try to >>>>>>>>>>>>>>>>>>>>>>> apply the answer to the Halting Problem, which >>>>>>>>>>>>>>>>>>>>>>> you do.

So the software engineering really is over your head? >>>>>>>>>>>>>>>>>>>>>> I see, so like Ben you have never actually written >>>>>>>>>>>>>>>>>>>>>> any code.

But you aren't talking about Software Engineering >>>>>>>>>>>>>>>>>>>>> unless you are lying about this applying to the >>>>>>>>>>>>>>>>>>>>> Halting Problem described by Linz, since that is >>>>>>>>>>>>>>>>>>>>> the Halting Problem of Computability Theory. >>>>>>>>>>>>>>>>>>>>>
Of course, the likely explanation is that you are >>>>>>>>>>>>>>>>>>>>> just ignorant of what you are talking about, so you >>>>>>>>>>>>>>>>>>>>> don't understand the diference.

Ben kept masking his coding incompetence this way. >>>>>>>>>>>>>>>>>>>>>> It never occurred to me that you have never >>>>>>>>>>>>>>>>>>>>>> written any code.

I have possibly written more WORKING code than you >>>>>>>>>>>>>>>>>>>>> have.

I don't believe you. Your inability to answer an >>>>>>>>>>>>>>>>>>>> straight forward
software engineering question seems to prove otherwise. >>>>>>>>>>>>>>>>>>>

What software engineering question?

Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?
Can D simulated by H terminate normally?

The answer to that question is NO,

Finally you admit an easily verified fact.

but that is because H doesn't, and can never do an >>>>>>>>>>>>>>>>> accurarte simulation per the definition of a UTM. >>>>>>>>>>>>>>>>>

If the simulation by a UTM would be wrong then you would >>>>>>>>>>>>>>>> have to be able
to point out the mistake in the simulation of D by H, >>>>>>>>>>>>>>>

No, the simulation by a ACTUAL UTM will reach a final state. >>>>>>>>>>>>>>>

I don't know why you say this when you already know that >>>>>>>>>>>>>> ⟨Ĥ⟩ correctly
simulated by embedded_H cannot possibly terminate normally. >>>>>>>>>>>>>

Because embedded_H doesn't actually "Correctly Simulate" >>>>>>>>>>>>> its input by the definintion aquired by your mentioning of >>>>>>>>>>>>> a UTM.

You have already agreed that it does simulate the first N steps >>>>>>>>>>>> correctly. It is just as obvious that the behavior pattern >>>>>>>>>>>> of N steps of
⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly >>>>>>>>>>>> terminate normally
even if the value of N is ∞.

But N steps in not ALL steps as required by the actual
definition of a UTM.

Actually N steps is the exact definition of a UTM for those N >>>>>>>>>> steps.
Just like with the H/D example after N steps we can see that >>>>>>>>>> neither
D correctly simulated by H nor ⟨Ĥ⟩ correctly simulated by >>>>>>>>>> embedded_H
can possibly terminate normally.

Nope, UTMs have no concept of only doing a partial simulation. >>>>>>>>>

When a simulating halt decider correctly simulates N steps of
its input
it derives the exact same N steps that a pure UTM would derive >>>>>>>> because
it is itself a UTM with extra features.

Just like a racing car is a street legal care with extra features >>>>>>> that makes it no longer street legal.

The fact that H aborts its simulation part way means it is no
longer a UTM

*Yet only at the point where it aborts its simulation*

Right, but that affect the behavior of ALL copies of it, since they
all act the same.

Do you think you are immortal because you haven't died yet, and
that everyone is immortal until the point in time they die?

Since it just proves it isn't a UTM, it can't assume that the copy
it is simulating is, it needs to account for that behavior.

The fact that the DESIGN logic to do this goes into an infinite
loop, doesn't mean that the program itself does.

Since H aborts its simulation and returns 0, its input will see its
copy do exactly the same thing and thus will Halt, making the
answer wrong.

Since H isn't a UTM, since if fails to meet the defintion, the fact
that it can't reach a final state is irrelevent, as is any
definiton of "Correct Simulation" that differs from what a UTM does. >>>>>
UTM(D,D) Halts, therefore the CORRECT SIMULATION (by a UTM which is
what is allowed to replace the actual behavior of the machine)
Halts, and thus the CORRECT answer is Halting.

You are just showing that you have fallen for your own Strawman
Deception that got you to use the wrong criteria.

At this point where it aborts its simulation we can see that it must >>>>>> do this to prevent its own infinite execution, thus conclusively
proving
that it correctly determined that its simulated input cannot possibly >>>>>> terminate normally.

How much longer are you going to play the fool and deny this?

No, it does so because it has been programmed to do so, and thus
ALL copies of it will do so.

It makes the error assuming that the copy it is simulating will do
something different than it does.

It makes no error. As you already admitted D correctly simulated by H
cannot possibly terminate normally thus its isomorphism of ⟨Ĥ⟩
correctly
simulated by embedded_H cannot possibly terminate normally.

Are you going to keep playing the fool on this?

Except that you are answering the wrong question.

In other words you want to keep playing the fool and dodging the
actual question that I am actually asking.

No, you are showing yourself to be the fool by not understand your own stupidity.

So you agreed that D correctly simulated H cannot possibly terminate
normally and the exact same thing goes for ⟨Ĥ⟩ correctly simulated by >> embedded_H.

No, I am saying that H can not correctly simulate the input H and give
an answer. If H DOES try to correctly simulate its input, then it can
never giv an answer.

Since you already acknowledged that D correctly simulated by H can never terminate normally and you did not need an infinite amount of time to
determine this then the isomorphic ⟨Ĥ⟩ correctly simulated by embedded_H can also be determined to never terminate normally and this
determination can be made in a finite amount of time.

In both cases this can be correctly determined after N steps of
simulation thus no need for the infinite simulation that you keep
insisting is necessary.



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

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

XPost: comp.theory, sci.logic

On 5/21/23 10:16 AM, olcott wrote:

On 5/20/2023 6:52 PM, Richard Damon wrote:

On 5/20/23 5:29 PM, olcott wrote:

On 5/20/2023 4:24 PM, Richard Damon wrote:

On 5/20/23 5:10 PM, olcott wrote:

On 5/20/2023 3:48 PM, Richard Damon wrote:

On 5/20/23 4:33 PM, olcott wrote:

On 5/20/2023 2:56 PM, Richard Damon wrote:

On 5/20/23 3:29 PM, olcott wrote:

On 5/20/2023 1:54 PM, Richard Damon wrote:

On 5/20/23 2:46 PM, olcott wrote:

On 5/20/2023 1:15 PM, Richard Damon wrote:

On 5/20/23 1:09 PM, olcott wrote:

On 5/20/2023 11:10 AM, Richard Damon wrote:

On 5/20/23 11:24 AM, olcott wrote:

On 5/20/2023 10:19 AM, Richard Damon wrote:

On 5/20/23 10:54 AM, olcott wrote:

On 5/20/2023 8:49 AM, Richard Damon wrote:

On 5/20/23 12:00 AM, olcott wrote:

On 5/19/2023 10:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 5/19/23 11:00 PM, olcott wrote:

On 5/19/2023 9:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 8:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>

Wrong Question!

In other words the question is over you head. >>>>>>>>>>>>>>>>>>>>>>>>> It took me many years to recognize this same >>>>>>>>>>>>>>>>>>>>>>>>> dodge by Ben.

No, it is the WRONG question once you try to >>>>>>>>>>>>>>>>>>>>>>>> apply the answer to the Halting Problem, which >>>>>>>>>>>>>>>>>>>>>>>> you do.

So the software engineering really is over your >>>>>>>>>>>>>>>>>>>>>>> head?
I see, so like Ben you have never actually >>>>>>>>>>>>>>>>>>>>>>> written any code.

But you aren't talking about Software Engineering >>>>>>>>>>>>>>>>>>>>>> unless you are lying about this applying to the >>>>>>>>>>>>>>>>>>>>>> Halting Problem described by Linz, since that is >>>>>>>>>>>>>>>>>>>>>> the Halting Problem of Computability Theory. >>>>>>>>>>>>>>>>>>>>>>
Of course, the likely explanation is that you are >>>>>>>>>>>>>>>>>>>>>> just ignorant of what you are talking about, so >>>>>>>>>>>>>>>>>>>>>> you don't understand the diference. >>>>>>>>>>>>>>>>>>>>>>

Ben kept masking his coding incompetence this way. >>>>>>>>>>>>>>>>>>>>>>> It never occurred to me that you have never >>>>>>>>>>>>>>>>>>>>>>> written any code.

I have possibly written more WORKING code than you >>>>>>>>>>>>>>>>>>>>>> have.

I don't believe you. Your inability to answer an >>>>>>>>>>>>>>>>>>>>> straight forward
software engineering question seems to prove >>>>>>>>>>>>>>>>>>>>> otherwise.

What software engineering question?

Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>

The answer to that question is NO,

Finally you admit an easily verified fact.

but that is because H doesn't, and can never do an >>>>>>>>>>>>>>>>>> accurarte simulation per the definition of a UTM. >>>>>>>>>>>>>>>>>>

If the simulation by a UTM would be wrong then you >>>>>>>>>>>>>>>>> would have to be able
to point out the mistake in the simulation of D by H, >>>>>>>>>>>>>>>>

No, the simulation by a ACTUAL UTM will reach a final >>>>>>>>>>>>>>>> state.

I don't know why you say this when you already know that >>>>>>>>>>>>>>> ⟨Ĥ⟩ correctly
simulated by embedded_H cannot possibly terminate normally. >>>>>>>>>>>>>>

Because embedded_H doesn't actually "Correctly Simulate" >>>>>>>>>>>>>> its input by the definintion aquired by your mentioning of >>>>>>>>>>>>>> a UTM.

You have already agreed that it does simulate the first N >>>>>>>>>>>>> steps
correctly. It is just as obvious that the behavior pattern >>>>>>>>>>>>> of N steps of
⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly >>>>>>>>>>>>> terminate normally
even if the value of N is ∞.

But N steps in not ALL steps as required by the actual >>>>>>>>>>>> definition of a UTM.

Actually N steps is the exact definition of a UTM for those N >>>>>>>>>>> steps.
Just like with the H/D example after N steps we can see that >>>>>>>>>>> neither
D correctly simulated by H nor ⟨Ĥ⟩ correctly simulated by >>>>>>>>>>> embedded_H
can possibly terminate normally.

Nope, UTMs have no concept of only doing a partial simulation. >>>>>>>>>>

When a simulating halt decider correctly simulates N steps of >>>>>>>>> its input
it derives the exact same N steps that a pure UTM would derive >>>>>>>>> because
it is itself a UTM with extra features.

Just like a racing car is a street legal care with extra
features that makes it no longer street legal.

The fact that H aborts its simulation part way means it is no
longer a UTM

*Yet only at the point where it aborts its simulation*

Right, but that affect the behavior of ALL copies of it, since
they all act the same.

Do you think you are immortal because you haven't died yet, and
that everyone is immortal until the point in time they die?

Since it just proves it isn't a UTM, it can't assume that the copy >>>>>> it is simulating is, it needs to account for that behavior.

The fact that the DESIGN logic to do this goes into an infinite
loop, doesn't mean that the program itself does.

Since H aborts its simulation and returns 0, its input will see
its copy do exactly the same thing and thus will Halt, making the
answer wrong.

Since H isn't a UTM, since if fails to meet the defintion, the
fact that it can't reach a final state is irrelevent, as is any
definiton of "Correct Simulation" that differs from what a UTM does. >>>>>>
UTM(D,D) Halts, therefore the CORRECT SIMULATION (by a UTM which
is what is allowed to replace the actual behavior of the machine)
Halts, and thus the CORRECT answer is Halting.

You are just showing that you have fallen for your own Strawman
Deception that got you to use the wrong criteria.

At this point where it aborts its simulation we can see that it must >>>>>>> do this to prevent its own infinite execution, thus conclusively >>>>>>> proving
that it correctly determined that its simulated input cannot
possibly
terminate normally.

How much longer are you going to play the fool and deny this?

No, it does so because it has been programmed to do so, and thus
ALL copies of it will do so.

It makes the error assuming that the copy it is simulating will do >>>>>> something different than it does.

It makes no error. As you already admitted D correctly simulated by H >>>>> cannot possibly terminate normally thus its isomorphism of ⟨Ĥ⟩
correctly
simulated by embedded_H cannot possibly terminate normally.

Are you going to keep playing the fool on this?

Except that you are answering the wrong question.

In other words you want to keep playing the fool and dodging the
actual question that I am actually asking.

No, you are showing yourself to be the fool by not understand your own
stupidity.

So you agreed that D correctly simulated H cannot possibly terminate
normally and the exact same thing goes for ⟨Ĥ⟩ correctly simulated by >>> embedded_H.

No, I am saying that H can not correctly simulate the input H and give
an answer. If H DOES try to correctly simulate its input, then it can
never giv an answer.

Since you already acknowledged that D correctly simulated by H can never terminate normally and you did not need an infinite amount of time to determine this then the isomorphic ⟨Ĥ⟩ correctly simulated by embedded_H can also be determined to never terminate normally and this
determination can be made in a finite amount of time.

In both cases this can be correctly determined after N steps of
simulation thus no need for the infinite simulation that you keep
insisting is necessary.

You keep on LYING about what I said. Any H that gives an answer can not "Correctly Simulate" this input per the definitions that allow
simulation to replace the behavior of the actual machine.

Thus, your statement is ILLFORMED, just like the Liar's Paradox.

Since your H doesn't "Correctly Simulate" its input, you can not use
logic that assumes it does, thus, since you keep on trying to, you show
you do not understand the principles of sound logic.

You are just proving that you have no idea about how truth works.

What are your actual "Stipulated" facts, and what is the sementic
connection to your answer.

Remember, the replacement of the behavior of the actual machine with the "Correct Simulation" (which you do) requires that "Correct Simulation"
includes the requirement of COMPLETE simulation.

Thus H can not do a "Correct Simulation" per the above AND abort its
simulation to give an answer, and ALL VERSION OF H (including embedded_H
which is just an alias for H) behave the same given the same input.

"augmenting" a UTM by letting it stop before it gets to the end, means
the machine is no longer a UTM, and its simulation no longer satisfies
the requirement to be a replacement for the actual machine.

A machine that SAYS its input in non-halting, is different than a
machine that indicates its input is non-halting by being, itself,
non-halting.

Saying they are the same is saying that a sign with the word "Blue" in
Red Letters, is the same thing as a Sign that written in the Color Blue.

You are just proving you ideas are worthless, because you cling to
invalid and unsound logic.

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

XPost: comp.theory, sci.logic

On 5/21/2023 11:54 AM, Richard Damon wrote:

On 5/21/23 10:16 AM, olcott wrote:

On 5/20/2023 6:52 PM, Richard Damon wrote:

On 5/20/23 5:29 PM, olcott wrote:

On 5/20/2023 4:24 PM, Richard Damon wrote:

On 5/20/23 5:10 PM, olcott wrote:

On 5/20/2023 3:48 PM, Richard Damon wrote:

On 5/20/23 4:33 PM, olcott wrote:

On 5/20/2023 2:56 PM, Richard Damon wrote:

On 5/20/23 3:29 PM, olcott wrote:

On 5/20/2023 1:54 PM, Richard Damon wrote:

On 5/20/23 2:46 PM, olcott wrote:

On 5/20/2023 1:15 PM, Richard Damon wrote:

On 5/20/23 1:09 PM, olcott wrote:

On 5/20/2023 11:10 AM, Richard Damon wrote:

On 5/20/23 11:24 AM, olcott wrote:

On 5/20/2023 10:19 AM, Richard Damon wrote:

On 5/20/23 10:54 AM, olcott wrote:

On 5/20/2023 8:49 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 5/20/23 12:00 AM, olcott wrote:

On 5/19/2023 10:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 5/19/23 11:00 PM, olcott wrote:

On 5/19/2023 9:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 8:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>

Wrong Question!

In other words the question is over you head. >>>>>>>>>>>>>>>>>>>>>>>>>> It took me many years to recognize this same >>>>>>>>>>>>>>>>>>>>>>>>>> dodge by Ben.

No, it is the WRONG question once you try to >>>>>>>>>>>>>>>>>>>>>>>>> apply the answer to the Halting Problem, which >>>>>>>>>>>>>>>>>>>>>>>>> you do.

So the software engineering really is over your >>>>>>>>>>>>>>>>>>>>>>>> head?
I see, so like Ben you have never actually >>>>>>>>>>>>>>>>>>>>>>>> written any code.

But you aren't talking about Software Engineering >>>>>>>>>>>>>>>>>>>>>>> unless you are lying about this applying to the >>>>>>>>>>>>>>>>>>>>>>> Halting Problem described by Linz, since that is >>>>>>>>>>>>>>>>>>>>>>> the Halting Problem of Computability Theory. >>>>>>>>>>>>>>>>>>>>>>>
Of course, the likely explanation is that you are >>>>>>>>>>>>>>>>>>>>>>> just ignorant of what you are talking about, so >>>>>>>>>>>>>>>>>>>>>>> you don't understand the diference. >>>>>>>>>>>>>>>>>>>>>>>

Ben kept masking his coding incompetence this way. >>>>>>>>>>>>>>>>>>>>>>>> It never occurred to me that you have never >>>>>>>>>>>>>>>>>>>>>>>> written any code.

I have possibly written more WORKING code than >>>>>>>>>>>>>>>>>>>>>>> you have.

I don't believe you. Your inability to answer an >>>>>>>>>>>>>>>>>>>>>> straight forward
software engineering question seems to prove >>>>>>>>>>>>>>>>>>>>>> otherwise.

What software engineering question?

Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>

The answer to that question is NO,

Finally you admit an easily verified fact. >>>>>>>>>>>>>>>>>>

but that is because H doesn't, and can never do an >>>>>>>>>>>>>>>>>>> accurarte simulation per the definition of a UTM. >>>>>>>>>>>>>>>>>>>

If the simulation by a UTM would be wrong then you >>>>>>>>>>>>>>>>>> would have to be able
to point out the mistake in the simulation of D by H, >>>>>>>>>>>>>>>>>

No, the simulation by a ACTUAL UTM will reach a final >>>>>>>>>>>>>>>>> state.

I don't know why you say this when you already know that >>>>>>>>>>>>>>>> ⟨Ĥ⟩ correctly
simulated by embedded_H cannot possibly terminate normally. >>>>>>>>>>>>>>>

Because embedded_H doesn't actually "Correctly Simulate" >>>>>>>>>>>>>>> its input by the definintion aquired by your mentioning >>>>>>>>>>>>>>> of a UTM.

You have already agreed that it does simulate the first N >>>>>>>>>>>>>> steps
correctly. It is just as obvious that the behavior pattern >>>>>>>>>>>>>> of N steps of
⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly >>>>>>>>>>>>>> terminate normally
even if the value of N is ∞.

But N steps in not ALL steps as required by the actual >>>>>>>>>>>>> definition of a UTM.

Actually N steps is the exact definition of a UTM for those >>>>>>>>>>>> N steps.
Just like with the H/D example after N steps we can see that >>>>>>>>>>>> neither
D correctly simulated by H nor ⟨Ĥ⟩ correctly simulated by >>>>>>>>>>>> embedded_H
can possibly terminate normally.

Nope, UTMs have no concept of only doing a partial simulation. >>>>>>>>>>>

When a simulating halt decider correctly simulates N steps of >>>>>>>>>> its input
it derives the exact same N steps that a pure UTM would derive >>>>>>>>>> because
it is itself a UTM with extra features.

Just like a racing car is a street legal care with extra
features that makes it no longer street legal.

The fact that H aborts its simulation part way means it is no >>>>>>>>> longer a UTM

*Yet only at the point where it aborts its simulation*

Right, but that affect the behavior of ALL copies of it, since
they all act the same.

Do you think you are immortal because you haven't died yet, and
that everyone is immortal until the point in time they die?

Since it just proves it isn't a UTM, it can't assume that the
copy it is simulating is, it needs to account for that behavior. >>>>>>>
The fact that the DESIGN logic to do this goes into an infinite
loop, doesn't mean that the program itself does.

Since H aborts its simulation and returns 0, its input will see
its copy do exactly the same thing and thus will Halt, making the >>>>>>> answer wrong.

Since H isn't a UTM, since if fails to meet the defintion, the
fact that it can't reach a final state is irrelevent, as is any
definiton of "Correct Simulation" that differs from what a UTM does. >>>>>>>
UTM(D,D) Halts, therefore the CORRECT SIMULATION (by a UTM which >>>>>>> is what is allowed to replace the actual behavior of the machine) >>>>>>> Halts, and thus the CORRECT answer is Halting.

You are just showing that you have fallen for your own Strawman
Deception that got you to use the wrong criteria.

At this point where it aborts its simulation we can see that it >>>>>>>> must
do this to prevent its own infinite execution, thus conclusively >>>>>>>> proving
that it correctly determined that its simulated input cannot
possibly
terminate normally.

How much longer are you going to play the fool and deny this?

No, it does so because it has been programmed to do so, and thus >>>>>>> ALL copies of it will do so.

It makes the error assuming that the copy it is simulating will
do something different than it does.

It makes no error. As you already admitted D correctly simulated by H >>>>>> cannot possibly terminate normally thus its isomorphism of ⟨Ĥ⟩ >>>>>> correctly
simulated by embedded_H cannot possibly terminate normally.

Are you going to keep playing the fool on this?

Except that you are answering the wrong question.

In other words you want to keep playing the fool and dodging the
actual question that I am actually asking.

No, you are showing yourself to be the fool by not understand your
own stupidity.

So you agreed that D correctly simulated H cannot possibly terminate
normally and the exact same thing goes for ⟨Ĥ⟩ correctly simulated by >>>> embedded_H.

No, I am saying that H can not correctly simulate the input H and
give an answer. If H DOES try to correctly simulate its input, then
it can never giv an answer.

Since you already acknowledged that D correctly simulated by H can never
terminate normally and you did not need an infinite amount of time to
determine this then the isomorphic ⟨Ĥ⟩ correctly simulated by embedded_H
can also be determined to never terminate normally and this
determination can be made in a finite amount of time.

In both cases this can be correctly determined after N steps of
simulation thus no need for the infinite simulation that you keep
insisting is necessary.

You keep on LYING about what I said. Any H that gives an answer can not "Correctly Simulate" this input per the definitions that allow
simulation to replace the behavior of the actual machine.

Since you already acknowledged that D correctly simulated by H cannot
possibly terminate normally (hence [key agreement]) and the H/D pair is isomorphic to the embedded_H / ⟨Ĥ⟩ pair you contradict yourself.

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

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

XPost: comp.theory, sci.logic

On 5/21/2023 1:39 PM, Richard Damon wrote:

On 5/21/23 2:12 PM, olcott wrote:

On 5/21/2023 11:54 AM, Richard Damon wrote:

On 5/21/23 10:16 AM, olcott wrote:

On 5/20/2023 6:52 PM, Richard Damon wrote:

On 5/20/23 5:29 PM, olcott wrote:

On 5/20/2023 4:24 PM, Richard Damon wrote:

On 5/20/23 5:10 PM, olcott wrote:

On 5/20/2023 3:48 PM, Richard Damon wrote:

On 5/20/23 4:33 PM, olcott wrote:

On 5/20/2023 2:56 PM, Richard Damon wrote:

On 5/20/23 3:29 PM, olcott wrote:

On 5/20/2023 1:54 PM, Richard Damon wrote:

On 5/20/23 2:46 PM, olcott wrote:

On 5/20/2023 1:15 PM, Richard Damon wrote:

On 5/20/23 1:09 PM, olcott wrote:

On 5/20/2023 11:10 AM, Richard Damon wrote:

On 5/20/23 11:24 AM, olcott wrote:

On 5/20/2023 10:19 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 5/20/23 10:54 AM, olcott wrote:

On 5/20/2023 8:49 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 5/20/23 12:00 AM, olcott wrote:

On 5/19/2023 10:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 11:00 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 9:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 8:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Wrong Question!

In other words the question is over you head. >>>>>>>>>>>>>>>>>>>>>>>>>>>> It took me many years to recognize this same >>>>>>>>>>>>>>>>>>>>>>>>>>>> dodge by Ben.

No, it is the WRONG question once you try to >>>>>>>>>>>>>>>>>>>>>>>>>>> apply the answer to the Halting Problem, >>>>>>>>>>>>>>>>>>>>>>>>>>> which you do.

So the software engineering really is over >>>>>>>>>>>>>>>>>>>>>>>>>> your head?
I see, so like Ben you have never actually >>>>>>>>>>>>>>>>>>>>>>>>>> written any code.

But you aren't talking about Software >>>>>>>>>>>>>>>>>>>>>>>>> Engineering unless you are lying about this >>>>>>>>>>>>>>>>>>>>>>>>> applying to the Halting Problem described by >>>>>>>>>>>>>>>>>>>>>>>>> Linz, since that is the Halting Problem of >>>>>>>>>>>>>>>>>>>>>>>>> Computability Theory.

Of course, the likely explanation is that you >>>>>>>>>>>>>>>>>>>>>>>>> are just ignorant of what you are talking >>>>>>>>>>>>>>>>>>>>>>>>> about, so you don't understand the diference. >>>>>>>>>>>>>>>>>>>>>>>>>

Ben kept masking his coding incompetence this >>>>>>>>>>>>>>>>>>>>>>>>>> way.
It never occurred to me that you have never >>>>>>>>>>>>>>>>>>>>>>>>>> written any code.

I have possibly written more WORKING code than >>>>>>>>>>>>>>>>>>>>>>>>> you have.

I don't believe you. Your inability to answer an >>>>>>>>>>>>>>>>>>>>>>>> straight forward
software engineering question seems to prove >>>>>>>>>>>>>>>>>>>>>>>> otherwise.

What software engineering question? >>>>>>>>>>>>>>>>>>>>>>>

Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>

The answer to that question is NO,

Finally you admit an easily verified fact. >>>>>>>>>>>>>>>>>>>>

but that is because H doesn't, and can never do an >>>>>>>>>>>>>>>>>>>>> accurarte simulation per the definition of a UTM. >>>>>>>>>>>>>>>>>>>>>

If the simulation by a UTM would be wrong then you >>>>>>>>>>>>>>>>>>>> would have to be able
to point out the mistake in the simulation of D by H, >>>>>>>>>>>>>>>>>>>

No, the simulation by a ACTUAL UTM will reach a final >>>>>>>>>>>>>>>>>>> state.

I don't know why you say this when you already know >>>>>>>>>>>>>>>>>> that ⟨Ĥ⟩ correctly
simulated by embedded_H cannot possibly terminate >>>>>>>>>>>>>>>>>> normally.

Because embedded_H doesn't actually "Correctly >>>>>>>>>>>>>>>>> Simulate" its input by the definintion aquired by your >>>>>>>>>>>>>>>>> mentioning of a UTM.

You have already agreed that it does simulate the first >>>>>>>>>>>>>>>> N steps
correctly. It is just as obvious that the behavior >>>>>>>>>>>>>>>> pattern of N steps of
⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly >>>>>>>>>>>>>>>> terminate normally
even if the value of N is ∞.

But N steps in not ALL steps as required by the actual >>>>>>>>>>>>>>> definition of a UTM.

Actually N steps is the exact definition of a UTM for >>>>>>>>>>>>>> those N steps.
Just like with the H/D example after N steps we can see >>>>>>>>>>>>>> that neither
D correctly simulated by H nor ⟨Ĥ⟩ correctly simulated by >>>>>>>>>>>>>> embedded_H
can possibly terminate normally.

Nope, UTMs have no concept of only doing a partial simulation. >>>>>>>>>>>>>

When a simulating halt decider correctly simulates N steps >>>>>>>>>>>> of its input
it derives the exact same N steps that a pure UTM would >>>>>>>>>>>> derive because
it is itself a UTM with extra features.

Just like a racing car is a street legal care with extra >>>>>>>>>>> features that makes it no longer street legal.

The fact that H aborts its simulation part way means it is no >>>>>>>>>>> longer a UTM

*Yet only at the point where it aborts its simulation*

Right, but that affect the behavior of ALL copies of it, since >>>>>>>>> they all act the same.

Do you think you are immortal because you haven't died yet, and >>>>>>>>> that everyone is immortal until the point in time they die?

Since it just proves it isn't a UTM, it can't assume that the >>>>>>>>> copy it is simulating is, it needs to account for that behavior. >>>>>>>>>
The fact that the DESIGN logic to do this goes into an infinite >>>>>>>>> loop, doesn't mean that the program itself does.

Since H aborts its simulation and returns 0, its input will see >>>>>>>>> its copy do exactly the same thing and thus will Halt, making >>>>>>>>> the answer wrong.

Since H isn't a UTM, since if fails to meet the defintion, the >>>>>>>>> fact that it can't reach a final state is irrelevent, as is any >>>>>>>>> definiton of "Correct Simulation" that differs from what a UTM >>>>>>>>> does.

UTM(D,D) Halts, therefore the CORRECT SIMULATION (by a UTM
which is what is allowed to replace the actual behavior of the >>>>>>>>> machine) Halts, and thus the CORRECT answer is Halting.

You are just showing that you have fallen for your own Strawman >>>>>>>>> Deception that got you to use the wrong criteria.

At this point where it aborts its simulation we can see that >>>>>>>>>> it must
do this to prevent its own infinite execution, thus
conclusively proving
that it correctly determined that its simulated input cannot >>>>>>>>>> possibly
terminate normally.

How much longer are you going to play the fool and deny this? >>>>>>>>>>

No, it does so because it has been programmed to do so, and
thus ALL copies of it will do so.

It makes the error assuming that the copy it is simulating will >>>>>>>>> do something different than it does.

It makes no error. As you already admitted D correctly simulated >>>>>>>> by H
cannot possibly terminate normally thus its isomorphism of ⟨Ĥ⟩ >>>>>>>> correctly
simulated by embedded_H cannot possibly terminate normally.

Are you going to keep playing the fool on this?

Except that you are answering the wrong question.

In other words you want to keep playing the fool and dodging the
actual question that I am actually asking.

No, you are showing yourself to be the fool by not understand your
own stupidity.

So you agreed that D correctly simulated H cannot possibly terminate >>>>>> normally and the exact same thing goes for ⟨Ĥ⟩ correctly simulated by
embedded_H.

No, I am saying that H can not correctly simulate the input H and
give an answer. If H DOES try to correctly simulate its input, then
it can never giv an answer.

Since you already acknowledged that D correctly simulated by H can
never
terminate normally and you did not need an infinite amount of time to
determine this then the isomorphic ⟨Ĥ⟩ correctly simulated by
embedded_H
can also be determined to never terminate normally and this
determination can be made in a finite amount of time.

In both cases this can be correctly determined after N steps of
simulation thus no need for the infinite simulation that you keep
insisting is necessary.

You keep on LYING about what I said. Any H that gives an answer can
not "Correctly Simulate" this input per the definitions that allow
simulation to replace the behavior of the actual machine.

Since you already acknowledged that D correctly simulated by H cannot
possibly terminate normally (hence [key agreement]) and the H/D pair is
isomorphic to the embedded_H / ⟨Ĥ⟩ pair you contradict yourself.

So?

D(D) / Ĥ (Ĥ) still halt since H returns non-halting, thus that answer is wrong for the Halting Problem.

It only seems wrong because all of the textbooks reject simulating
halt deciders out-of-hand without review incorrectly assuming that
simulation cannot possibly be used as the basis of a halt decider:

We cannot find the answer by simulating the action of M on w, say by
performing it on a universal Turing machine, because there is no limit
on the length of the computation. If M enters an infinite loop, then no
matter how long we wait, we can never be sure that M is in fact in a
loop. It may simply be a case of a very long computation. What we need
is an algorithm that can determine the correct answer for any M and w by performing some analysis on the machine's description and the input. But
as we now show, no such algorithm exists.(Linz:1990:317)

*THIS IS NECESSARILY TRUE*
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.

This only takes N steps of correct simulation.



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

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

XPost: comp.theory, sci.logic

On 5/21/23 2:12 PM, olcott wrote:

On 5/21/2023 11:54 AM, Richard Damon wrote:

On 5/21/23 10:16 AM, olcott wrote:

On 5/20/2023 6:52 PM, Richard Damon wrote:

On 5/20/23 5:29 PM, olcott wrote:

On 5/20/2023 4:24 PM, Richard Damon wrote:

On 5/20/23 5:10 PM, olcott wrote:

On 5/20/2023 3:48 PM, Richard Damon wrote:

On 5/20/23 4:33 PM, olcott wrote:

On 5/20/2023 2:56 PM, Richard Damon wrote:

On 5/20/23 3:29 PM, olcott wrote:

On 5/20/2023 1:54 PM, Richard Damon wrote:

On 5/20/23 2:46 PM, olcott wrote:

On 5/20/2023 1:15 PM, Richard Damon wrote:

On 5/20/23 1:09 PM, olcott wrote:

On 5/20/2023 11:10 AM, Richard Damon wrote:

On 5/20/23 11:24 AM, olcott wrote:

On 5/20/2023 10:19 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 5/20/23 10:54 AM, olcott wrote:

On 5/20/2023 8:49 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 5/20/23 12:00 AM, olcott wrote:

On 5/19/2023 10:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 5/19/23 11:00 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 9:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 8:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>

Wrong Question!

In other words the question is over you head. >>>>>>>>>>>>>>>>>>>>>>>>>>> It took me many years to recognize this same >>>>>>>>>>>>>>>>>>>>>>>>>>> dodge by Ben.

No, it is the WRONG question once you try to >>>>>>>>>>>>>>>>>>>>>>>>>> apply the answer to the Halting Problem, which >>>>>>>>>>>>>>>>>>>>>>>>>> you do.

So the software engineering really is over your >>>>>>>>>>>>>>>>>>>>>>>>> head?
I see, so like Ben you have never actually >>>>>>>>>>>>>>>>>>>>>>>>> written any code.

But you aren't talking about Software >>>>>>>>>>>>>>>>>>>>>>>> Engineering unless you are lying about this >>>>>>>>>>>>>>>>>>>>>>>> applying to the Halting Problem described by >>>>>>>>>>>>>>>>>>>>>>>> Linz, since that is the Halting Problem of >>>>>>>>>>>>>>>>>>>>>>>> Computability Theory.

Of course, the likely explanation is that you >>>>>>>>>>>>>>>>>>>>>>>> are just ignorant of what you are talking about, >>>>>>>>>>>>>>>>>>>>>>>> so you don't understand the diference. >>>>>>>>>>>>>>>>>>>>>>>>

Ben kept masking his coding incompetence this way. >>>>>>>>>>>>>>>>>>>>>>>>> It never occurred to me that you have never >>>>>>>>>>>>>>>>>>>>>>>>> written any code.

I have possibly written more WORKING code than >>>>>>>>>>>>>>>>>>>>>>>> you have.

I don't believe you. Your inability to answer an >>>>>>>>>>>>>>>>>>>>>>> straight forward
software engineering question seems to prove >>>>>>>>>>>>>>>>>>>>>>> otherwise.

What software engineering question? >>>>>>>>>>>>>>>>>>>>>>

Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>

The answer to that question is NO,

Finally you admit an easily verified fact. >>>>>>>>>>>>>>>>>>>

but that is because H doesn't, and can never do an >>>>>>>>>>>>>>>>>>>> accurarte simulation per the definition of a UTM. >>>>>>>>>>>>>>>>>>>>

If the simulation by a UTM would be wrong then you >>>>>>>>>>>>>>>>>>> would have to be able
to point out the mistake in the simulation of D by H, >>>>>>>>>>>>>>>>>>

No, the simulation by a ACTUAL UTM will reach a final >>>>>>>>>>>>>>>>>> state.

I don't know why you say this when you already know >>>>>>>>>>>>>>>>> that ⟨Ĥ⟩ correctly
simulated by embedded_H cannot possibly terminate >>>>>>>>>>>>>>>>> normally.

Because embedded_H doesn't actually "Correctly Simulate" >>>>>>>>>>>>>>>> its input by the definintion aquired by your mentioning >>>>>>>>>>>>>>>> of a UTM.

You have already agreed that it does simulate the first N >>>>>>>>>>>>>>> steps
correctly. It is just as obvious that the behavior >>>>>>>>>>>>>>> pattern of N steps of
⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly >>>>>>>>>>>>>>> terminate normally
even if the value of N is ∞.

But N steps in not ALL steps as required by the actual >>>>>>>>>>>>>> definition of a UTM.

Actually N steps is the exact definition of a UTM for those >>>>>>>>>>>>> N steps.
Just like with the H/D example after N steps we can see >>>>>>>>>>>>> that neither
D correctly simulated by H nor ⟨Ĥ⟩ correctly simulated by >>>>>>>>>>>>> embedded_H
can possibly terminate normally.

Nope, UTMs have no concept of only doing a partial simulation. >>>>>>>>>>>>

When a simulating halt decider correctly simulates N steps of >>>>>>>>>>> its input
it derives the exact same N steps that a pure UTM would
derive because
it is itself a UTM with extra features.

Just like a racing car is a street legal care with extra
features that makes it no longer street legal.

The fact that H aborts its simulation part way means it is no >>>>>>>>>> longer a UTM

*Yet only at the point where it aborts its simulation*

Right, but that affect the behavior of ALL copies of it, since >>>>>>>> they all act the same.

Do you think you are immortal because you haven't died yet, and >>>>>>>> that everyone is immortal until the point in time they die?

Since it just proves it isn't a UTM, it can't assume that the
copy it is simulating is, it needs to account for that behavior. >>>>>>>>
The fact that the DESIGN logic to do this goes into an infinite >>>>>>>> loop, doesn't mean that the program itself does.

Since H aborts its simulation and returns 0, its input will see >>>>>>>> its copy do exactly the same thing and thus will Halt, making
the answer wrong.

Since H isn't a UTM, since if fails to meet the defintion, the >>>>>>>> fact that it can't reach a final state is irrelevent, as is any >>>>>>>> definiton of "Correct Simulation" that differs from what a UTM >>>>>>>> does.

UTM(D,D) Halts, therefore the CORRECT SIMULATION (by a UTM which >>>>>>>> is what is allowed to replace the actual behavior of the
machine) Halts, and thus the CORRECT answer is Halting.

You are just showing that you have fallen for your own Strawman >>>>>>>> Deception that got you to use the wrong criteria.

At this point where it aborts its simulation we can see that it >>>>>>>>> must
do this to prevent its own infinite execution, thus
conclusively proving
that it correctly determined that its simulated input cannot >>>>>>>>> possibly
terminate normally.

How much longer are you going to play the fool and deny this? >>>>>>>>>

No, it does so because it has been programmed to do so, and thus >>>>>>>> ALL copies of it will do so.

It makes the error assuming that the copy it is simulating will >>>>>>>> do something different than it does.

It makes no error. As you already admitted D correctly simulated >>>>>>> by H
cannot possibly terminate normally thus its isomorphism of ⟨Ĥ⟩ >>>>>>> correctly
simulated by embedded_H cannot possibly terminate normally.

Are you going to keep playing the fool on this?

Except that you are answering the wrong question.

In other words you want to keep playing the fool and dodging the
actual question that I am actually asking.

No, you are showing yourself to be the fool by not understand your
own stupidity.

So you agreed that D correctly simulated H cannot possibly terminate >>>>> normally and the exact same thing goes for ⟨Ĥ⟩ correctly simulated by
embedded_H.

No, I am saying that H can not correctly simulate the input H and
give an answer. If H DOES try to correctly simulate its input, then
it can never giv an answer.

Since you already acknowledged that D correctly simulated by H can never >>> terminate normally and you did not need an infinite amount of time to
determine this then the isomorphic ⟨Ĥ⟩ correctly simulated by embedded_H
can also be determined to never terminate normally and this
determination can be made in a finite amount of time.

In both cases this can be correctly determined after N steps of
simulation thus no need for the infinite simulation that you keep
insisting is necessary.

You keep on LYING about what I said. Any H that gives an answer can
not "Correctly Simulate" this input per the definitions that allow
simulation to replace the behavior of the actual machine.

Since you already acknowledged that D correctly simulated by H cannot possibly terminate normally (hence [key agreement]) and the H/D pair is isomorphic to the embedded_H / ⟨Ĥ⟩ pair you contradict yourself.

So?

D(D) / Ĥ (Ĥ) still halt since H returns non-halting, thus that answer is wrong for the Halting Problem.

The problem is that the question is about the behavior of the actual
machine, and the logic to transfer that behavior to a simulation
requires a simulation that H doesn't do, so H's inability to simulate to
a final state is irrelevent.


Your arguement is based on unsound and invalid arguements that become a
LIE by your refusal to accept that position.

YOU ARE JUST SHOWING YOU ARE AN STUPID IGNORANT PATHOLOGICAL LIAR.

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

XPost: comp.theory, sci.logic

On 5/21/23 2:50 PM, olcott wrote:

On 5/21/2023 1:39 PM, Richard Damon wrote:

On 5/21/23 2:12 PM, olcott wrote:

On 5/21/2023 11:54 AM, Richard Damon wrote:

On 5/21/23 10:16 AM, olcott wrote:

On 5/20/2023 6:52 PM, Richard Damon wrote:

On 5/20/23 5:29 PM, olcott wrote:

On 5/20/2023 4:24 PM, Richard Damon wrote:

On 5/20/23 5:10 PM, olcott wrote:

On 5/20/2023 3:48 PM, Richard Damon wrote:

On 5/20/23 4:33 PM, olcott wrote:

On 5/20/2023 2:56 PM, Richard Damon wrote:

On 5/20/23 3:29 PM, olcott wrote:

On 5/20/2023 1:54 PM, Richard Damon wrote:

On 5/20/23 2:46 PM, olcott wrote:

On 5/20/2023 1:15 PM, Richard Damon wrote:

On 5/20/23 1:09 PM, olcott wrote:

On 5/20/2023 11:10 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 5/20/23 11:24 AM, olcott wrote:

On 5/20/2023 10:19 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 5/20/23 10:54 AM, olcott wrote:

On 5/20/2023 8:49 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 5/20/23 12:00 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 10:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 11:00 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 9:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 8:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Wrong Question!

In other words the question is over you head. >>>>>>>>>>>>>>>>>>>>>>>>>>>>> It took me many years to recognize this >>>>>>>>>>>>>>>>>>>>>>>>>>>>> same dodge by Ben.

No, it is the WRONG question once you try to >>>>>>>>>>>>>>>>>>>>>>>>>>>> apply the answer to the Halting Problem, >>>>>>>>>>>>>>>>>>>>>>>>>>>> which you do.

So the software engineering really is over >>>>>>>>>>>>>>>>>>>>>>>>>>> your head?
I see, so like Ben you have never actually >>>>>>>>>>>>>>>>>>>>>>>>>>> written any code.

But you aren't talking about Software >>>>>>>>>>>>>>>>>>>>>>>>>> Engineering unless you are lying about this >>>>>>>>>>>>>>>>>>>>>>>>>> applying to the Halting Problem described by >>>>>>>>>>>>>>>>>>>>>>>>>> Linz, since that is the Halting Problem of >>>>>>>>>>>>>>>>>>>>>>>>>> Computability Theory.

Of course, the likely explanation is that you >>>>>>>>>>>>>>>>>>>>>>>>>> are just ignorant of what you are talking >>>>>>>>>>>>>>>>>>>>>>>>>> about, so you don't understand the diference. >>>>>>>>>>>>>>>>>>>>>>>>>>

Ben kept masking his coding incompetence this >>>>>>>>>>>>>>>>>>>>>>>>>>> way.
It never occurred to me that you have never >>>>>>>>>>>>>>>>>>>>>>>>>>> written any code.

I have possibly written more WORKING code than >>>>>>>>>>>>>>>>>>>>>>>>>> you have.

I don't believe you. Your inability to answer >>>>>>>>>>>>>>>>>>>>>>>>> an straight forward
software engineering question seems to prove >>>>>>>>>>>>>>>>>>>>>>>>> otherwise.

What software engineering question? >>>>>>>>>>>>>>>>>>>>>>>>

Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>

The answer to that question is NO,

Finally you admit an easily verified fact. >>>>>>>>>>>>>>>>>>>>>

but that is because H doesn't, and can never do an >>>>>>>>>>>>>>>>>>>>>> accurarte simulation per the definition of a UTM. >>>>>>>>>>>>>>>>>>>>>>

If the simulation by a UTM would be wrong then you >>>>>>>>>>>>>>>>>>>>> would have to be able
to point out the mistake in the simulation of D by H, >>>>>>>>>>>>>>>>>>>>

No, the simulation by a ACTUAL UTM will reach a >>>>>>>>>>>>>>>>>>>> final state.

I don't know why you say this when you already know >>>>>>>>>>>>>>>>>>> that ⟨Ĥ⟩ correctly
simulated by embedded_H cannot possibly terminate >>>>>>>>>>>>>>>>>>> normally.

Because embedded_H doesn't actually "Correctly >>>>>>>>>>>>>>>>>> Simulate" its input by the definintion aquired by your >>>>>>>>>>>>>>>>>> mentioning of a UTM.

You have already agreed that it does simulate the first >>>>>>>>>>>>>>>>> N steps
correctly. It is just as obvious that the behavior >>>>>>>>>>>>>>>>> pattern of N steps of
⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly >>>>>>>>>>>>>>>>> terminate normally
even if the value of N is ∞.

But N steps in not ALL steps as required by the actual >>>>>>>>>>>>>>>> definition of a UTM.

Actually N steps is the exact definition of a UTM for >>>>>>>>>>>>>>> those N steps.
Just like with the H/D example after N steps we can see >>>>>>>>>>>>>>> that neither
D correctly simulated by H nor ⟨Ĥ⟩ correctly simulated by >>>>>>>>>>>>>>> embedded_H
can possibly terminate normally.

Nope, UTMs have no concept of only doing a partial >>>>>>>>>>>>>> simulation.

When a simulating halt decider correctly simulates N steps >>>>>>>>>>>>> of its input
it derives the exact same N steps that a pure UTM would >>>>>>>>>>>>> derive because
it is itself a UTM with extra features.

Just like a racing car is a street legal care with extra >>>>>>>>>>>> features that makes it no longer street legal.

The fact that H aborts its simulation part way means it is >>>>>>>>>>>> no longer a UTM

*Yet only at the point where it aborts its simulation*

Right, but that affect the behavior of ALL copies of it, since >>>>>>>>>> they all act the same.

Do you think you are immortal because you haven't died yet, >>>>>>>>>> and that everyone is immortal until the point in time they die? >>>>>>>>>>
Since it just proves it isn't a UTM, it can't assume that the >>>>>>>>>> copy it is simulating is, it needs to account for that behavior. >>>>>>>>>>
The fact that the DESIGN logic to do this goes into an
infinite loop, doesn't mean that the program itself does.

Since H aborts its simulation and returns 0, its input will >>>>>>>>>> see its copy do exactly the same thing and thus will Halt, >>>>>>>>>> making the answer wrong.

Since H isn't a UTM, since if fails to meet the defintion, the >>>>>>>>>> fact that it can't reach a final state is irrelevent, as is >>>>>>>>>> any definiton of "Correct Simulation" that differs from what a >>>>>>>>>> UTM does.

UTM(D,D) Halts, therefore the CORRECT SIMULATION (by a UTM >>>>>>>>>> which is what is allowed to replace the actual behavior of the >>>>>>>>>> machine) Halts, and thus the CORRECT answer is Halting.

You are just showing that you have fallen for your own
Strawman Deception that got you to use the wrong criteria. >>>>>>>>>>

At this point where it aborts its simulation we can see that >>>>>>>>>>> it must
do this to prevent its own infinite execution, thus
conclusively proving
that it correctly determined that its simulated input cannot >>>>>>>>>>> possibly
terminate normally.

How much longer are you going to play the fool and deny this? >>>>>>>>>>>

No, it does so because it has been programmed to do so, and >>>>>>>>>> thus ALL copies of it will do so.

It makes the error assuming that the copy it is simulating >>>>>>>>>> will do something different than it does.

It makes no error. As you already admitted D correctly
simulated by H
cannot possibly terminate normally thus its isomorphism of ⟨Ĥ⟩ >>>>>>>>> correctly
simulated by embedded_H cannot possibly terminate normally.

Are you going to keep playing the fool on this?

Except that you are answering the wrong question.

In other words you want to keep playing the fool and dodging the >>>>>>> actual question that I am actually asking.

No, you are showing yourself to be the fool by not understand your >>>>>> own stupidity.

So you agreed that D correctly simulated H cannot possibly terminate >>>>>>> normally and the exact same thing goes for ⟨Ĥ⟩ correctly
simulated by
embedded_H.

No, I am saying that H can not correctly simulate the input H and
give an answer. If H DOES try to correctly simulate its input,
then it can never giv an answer.

Since you already acknowledged that D correctly simulated by H can
never
terminate normally and you did not need an infinite amount of time to >>>>> determine this then the isomorphic ⟨Ĥ⟩ correctly simulated by
embedded_H
can also be determined to never terminate normally and this
determination can be made in a finite amount of time.

In both cases this can be correctly determined after N steps of
simulation thus no need for the infinite simulation that you keep
insisting is necessary.

You keep on LYING about what I said. Any H that gives an answer can
not "Correctly Simulate" this input per the definitions that allow
simulation to replace the behavior of the actual machine.

Since you already acknowledged that D correctly simulated by H cannot
possibly terminate normally (hence [key agreement]) and the H/D pair is
isomorphic to the embedded_H / ⟨Ĥ⟩ pair you contradict yourself.

So?

D(D) / Ĥ (Ĥ) still halt since H returns non-halting, thus that answer
is wrong for the Halting Problem.

It only seems wrong because all of the textbooks reject simulating
halt deciders out-of-hand without review incorrectly assuming that
simulation cannot possibly be used as the basis of a halt decider:

No, it is wrong because the question asks about the actual machine, and
that halts, so the right answer is HALTING.

Unless "Simulating Halting Deciders" aren't actually a subclass of Halt Deciders, and thus aren't actually germane to the problem, there answer
has to match the actual question, not your strawman.

We cannot find the answer by simulating the action of M on w, say by performing it on a universal Turing machine, because there is no limit
on the length of the computation. If M enters an infinite loop, then no matter how long we wait, we can never be sure that M is in fact in a
loop. It may simply be a case of a very long computation. What we need
is an algorithm that can determine the correct answer for any M and w by performing some analysis on the machine's description and the input. But
as we now show, no such algorithm exists.(Linz:1990:317)

Right, we can't just use a UTM to get the answer, because that won't
give us non-halting in finite time.

That doesn't give you the right to give a wrong answer.

Your "logic" that shows your claim the answer is right is just
incorrect, as it assumes the copy of H in the machine behaves
differently than the copy of H deciding the answer, which is impossible.


If you want to claim otherwise, show the actual step in the direct
execution of D calling H(D,D) and of the direct call to H(D,D) that
difffers.

NOT your simulation of D, but the actual direct exectution of D calling
H(D,D). I say that because your "simulation" of D(D) doesn't actually
show the simulation of that call to H, because it isn't correct. You
claim the pages of irrelevent trace don't matter, but for your claim to
be correct, you need to show where those two machine execution diverge,
with both being calls to H(D,D), just from different contexts, where H
is DEFINED to be a Computation that is only a function of its defined
inputs, and not the context of its call.


YOU FAIL.

*THIS IS NECESSARILY TRUE*
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.

This only takes N steps of correct simulation.

No, it does NOT "Correctly Simulate" per the definition of a UTM, which
is the ONLY definition that allows changing from the actual machine to a simulation, so your statement has a false premise.

H does NOT "Correct Simulate" the input per the needed definition, so
has no grounds to call the machine non-halting.

You are just too ignorant of the actual meaning of the words to
understand this.

You also don't seem to understand that an answer can't be both wrong and
right at the same time to a well formed question, which the Halting
Problem is.

You are just proving your stupidity.

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

XPost: comp.theory, sci.logic

On 5/21/2023 2:02 PM, Richard Damon wrote:

On 5/21/23 2:50 PM, olcott wrote:

On 5/21/2023 1:39 PM, Richard Damon wrote:

On 5/21/23 2:12 PM, olcott wrote:

On 5/21/2023 11:54 AM, Richard Damon wrote:

On 5/21/23 10:16 AM, olcott wrote:

On 5/20/2023 6:52 PM, Richard Damon wrote:

On 5/20/23 5:29 PM, olcott wrote:

On 5/20/2023 4:24 PM, Richard Damon wrote:

On 5/20/23 5:10 PM, olcott wrote:

On 5/20/2023 3:48 PM, Richard Damon wrote:

On 5/20/23 4:33 PM, olcott wrote:

On 5/20/2023 2:56 PM, Richard Damon wrote:

On 5/20/23 3:29 PM, olcott wrote:

On 5/20/2023 1:54 PM, Richard Damon wrote:

On 5/20/23 2:46 PM, olcott wrote:

On 5/20/2023 1:15 PM, Richard Damon wrote:

On 5/20/23 1:09 PM, olcott wrote:

On 5/20/2023 11:10 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 5/20/23 11:24 AM, olcott wrote:

On 5/20/2023 10:19 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 5/20/23 10:54 AM, olcott wrote:

On 5/20/2023 8:49 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 12:00 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 10:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 11:00 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 9:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 8:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Wrong Question!

In other words the question is over you head. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It took me many years to recognize this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same dodge by Ben.

No, it is the WRONG question once you try >>>>>>>>>>>>>>>>>>>>>>>>>>>>> to apply the answer to the Halting Problem, >>>>>>>>>>>>>>>>>>>>>>>>>>>>> which you do.

So the software engineering really is over >>>>>>>>>>>>>>>>>>>>>>>>>>>> your head?
I see, so like Ben you have never actually >>>>>>>>>>>>>>>>>>>>>>>>>>>> written any code.

But you aren't talking about Software >>>>>>>>>>>>>>>>>>>>>>>>>>> Engineering unless you are lying about this >>>>>>>>>>>>>>>>>>>>>>>>>>> applying to the Halting Problem described by >>>>>>>>>>>>>>>>>>>>>>>>>>> Linz, since that is the Halting Problem of >>>>>>>>>>>>>>>>>>>>>>>>>>> Computability Theory.

Of course, the likely explanation is that you >>>>>>>>>>>>>>>>>>>>>>>>>>> are just ignorant of what you are talking >>>>>>>>>>>>>>>>>>>>>>>>>>> about, so you don't understand the diference. >>>>>>>>>>>>>>>>>>>>>>>>>>>

Ben kept masking his coding incompetence >>>>>>>>>>>>>>>>>>>>>>>>>>>> this way.
It never occurred to me that you have never >>>>>>>>>>>>>>>>>>>>>>>>>>>> written any code.

I have possibly written more WORKING code >>>>>>>>>>>>>>>>>>>>>>>>>>> than you have.

I don't believe you. Your inability to answer >>>>>>>>>>>>>>>>>>>>>>>>>> an straight forward
software engineering question seems to prove >>>>>>>>>>>>>>>>>>>>>>>>>> otherwise.

What software engineering question? >>>>>>>>>>>>>>>>>>>>>>>>>

Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>

The answer to that question is NO, >>>>>>>>>>>>>>>>>>>>>>

Finally you admit an easily verified fact. >>>>>>>>>>>>>>>>>>>>>>

but that is because H doesn't, and can never do >>>>>>>>>>>>>>>>>>>>>>> an accurarte simulation per the definition of a UTM. >>>>>>>>>>>>>>>>>>>>>>>

If the simulation by a UTM would be wrong then you >>>>>>>>>>>>>>>>>>>>>> would have to be able
to point out the mistake in the simulation of D by H, >>>>>>>>>>>>>>>>>>>>>

No, the simulation by a ACTUAL UTM will reach a >>>>>>>>>>>>>>>>>>>>> final state.

I don't know why you say this when you already know >>>>>>>>>>>>>>>>>>>> that ⟨Ĥ⟩ correctly
simulated by embedded_H cannot possibly terminate >>>>>>>>>>>>>>>>>>>> normally.

Because embedded_H doesn't actually "Correctly >>>>>>>>>>>>>>>>>>> Simulate" its input by the definintion aquired by >>>>>>>>>>>>>>>>>>> your mentioning of a UTM.

You have already agreed that it does simulate the >>>>>>>>>>>>>>>>>> first N steps
correctly. It is just as obvious that the behavior >>>>>>>>>>>>>>>>>> pattern of N steps of
⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly >>>>>>>>>>>>>>>>>> terminate normally
even if the value of N is ∞.

But N steps in not ALL steps as required by the actual >>>>>>>>>>>>>>>>> definition of a UTM.

Actually N steps is the exact definition of a UTM for >>>>>>>>>>>>>>>> those N steps.
Just like with the H/D example after N steps we can see >>>>>>>>>>>>>>>> that neither
D correctly simulated by H nor ⟨Ĥ⟩ correctly simulated >>>>>>>>>>>>>>>> by embedded_H
can possibly terminate normally.

Nope, UTMs have no concept of only doing a partial >>>>>>>>>>>>>>> simulation.

When a simulating halt decider correctly simulates N steps >>>>>>>>>>>>>> of its input
it derives the exact same N steps that a pure UTM would >>>>>>>>>>>>>> derive because
it is itself a UTM with extra features.

Just like a racing car is a street legal care with extra >>>>>>>>>>>>> features that makes it no longer street legal.

The fact that H aborts its simulation part way means it is >>>>>>>>>>>>> no longer a UTM

*Yet only at the point where it aborts its simulation*

Right, but that affect the behavior of ALL copies of it, >>>>>>>>>>> since they all act the same.

Do you think you are immortal because you haven't died yet, >>>>>>>>>>> and that everyone is immortal until the point in time they die? >>>>>>>>>>>
Since it just proves it isn't a UTM, it can't assume that the >>>>>>>>>>> copy it is simulating is, it needs to account for that behavior. >>>>>>>>>>>
The fact that the DESIGN logic to do this goes into an
infinite loop, doesn't mean that the program itself does. >>>>>>>>>>>
Since H aborts its simulation and returns 0, its input will >>>>>>>>>>> see its copy do exactly the same thing and thus will Halt, >>>>>>>>>>> making the answer wrong.

Since H isn't a UTM, since if fails to meet the defintion, >>>>>>>>>>> the fact that it can't reach a final state is irrelevent, as >>>>>>>>>>> is any definiton of "Correct Simulation" that differs from >>>>>>>>>>> what a UTM does.

UTM(D,D) Halts, therefore the CORRECT SIMULATION (by a UTM >>>>>>>>>>> which is what is allowed to replace the actual behavior of >>>>>>>>>>> the machine) Halts, and thus the CORRECT answer is Halting. >>>>>>>>>>>
You are just showing that you have fallen for your own
Strawman Deception that got you to use the wrong criteria. >>>>>>>>>>>

At this point where it aborts its simulation we can see that >>>>>>>>>>>> it must
do this to prevent its own infinite execution, thus
conclusively proving
that it correctly determined that its simulated input cannot >>>>>>>>>>>> possibly
terminate normally.

How much longer are you going to play the fool and deny this? >>>>>>>>>>>>

No, it does so because it has been programmed to do so, and >>>>>>>>>>> thus ALL copies of it will do so.

It makes the error assuming that the copy it is simulating >>>>>>>>>>> will do something different than it does.

It makes no error. As you already admitted D correctly
simulated by H
cannot possibly terminate normally thus its isomorphism of ⟨Ĥ⟩ >>>>>>>>>> correctly
simulated by embedded_H cannot possibly terminate normally. >>>>>>>>>>
Are you going to keep playing the fool on this?

Except that you are answering the wrong question.

In other words you want to keep playing the fool and dodging the >>>>>>>> actual question that I am actually asking.

No, you are showing yourself to be the fool by not understand
your own stupidity.

So you agreed that D correctly simulated H cannot possibly
terminate
normally and the exact same thing goes for ⟨Ĥ⟩ correctly
simulated by
embedded_H.

No, I am saying that H can not correctly simulate the input H and >>>>>>> give an answer. If H DOES try to correctly simulate its input,
then it can never giv an answer.

Since you already acknowledged that D correctly simulated by H can >>>>>> never
terminate normally and you did not need an infinite amount of time to >>>>>> determine this then the isomorphic ⟨Ĥ⟩ correctly simulated by >>>>>> embedded_H
can also be determined to never terminate normally and this
determination can be made in a finite amount of time.

In both cases this can be correctly determined after N steps of
simulation thus no need for the infinite simulation that you keep
insisting is necessary.

You keep on LYING about what I said. Any H that gives an answer can
not "Correctly Simulate" this input per the definitions that allow
simulation to replace the behavior of the actual machine.

Since you already acknowledged that D correctly simulated by H cannot
possibly terminate normally (hence [key agreement]) and the H/D pair is >>>> isomorphic to the embedded_H / ⟨Ĥ⟩ pair you contradict yourself.

So?

D(D) / Ĥ (Ĥ) still halt since H returns non-halting, thus that answer
is wrong for the Halting Problem.

It only seems wrong because all of the textbooks reject simulating
halt deciders out-of-hand without review incorrectly assuming that
simulation cannot possibly be used as the basis of a halt decider:

No, it is wrong because the question asks about the actual machine, and
that halts, so the right answer is HALTING.

Yet any theory of computation computer scientist knows that a simulation
of N steps by a UTM does provide that actual behavior of the actual
input to this UTM.

They also know that when the input to this UTM is defined to have a pathological relationship to this UTM that this changes the behavior of
this correctly simulated input.

Maybe I should begin my paper with this self-evident truth before
proceeding to the notion of a simulating halt decider.

In any case the perfect isomorphism between H/D and embedded_H / ⟨Ĥ⟩ already fully proves this point.

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

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

XPost: comp.theory, sci.logic

On 5/22/23 10:22 AM, olcott wrote:

On 5/21/2023 2:02 PM, Richard Damon wrote:

On 5/21/23 2:50 PM, olcott wrote:

On 5/21/2023 1:39 PM, Richard Damon wrote:

On 5/21/23 2:12 PM, olcott wrote:

On 5/21/2023 11:54 AM, Richard Damon wrote:

On 5/21/23 10:16 AM, olcott wrote:

On 5/20/2023 6:52 PM, Richard Damon wrote:

On 5/20/23 5:29 PM, olcott wrote:

On 5/20/2023 4:24 PM, Richard Damon wrote:

On 5/20/23 5:10 PM, olcott wrote:

On 5/20/2023 3:48 PM, Richard Damon wrote:

On 5/20/23 4:33 PM, olcott wrote:

On 5/20/2023 2:56 PM, Richard Damon wrote:

On 5/20/23 3:29 PM, olcott wrote:

On 5/20/2023 1:54 PM, Richard Damon wrote:

On 5/20/23 2:46 PM, olcott wrote:

On 5/20/2023 1:15 PM, Richard Damon wrote:

On 5/20/23 1:09 PM, olcott wrote:

On 5/20/2023 11:10 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 5/20/23 11:24 AM, olcott wrote:

On 5/20/2023 10:19 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 5/20/23 10:54 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 8:49 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 12:00 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 10:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 11:00 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 9:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 8:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Wrong Question! >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

In other words the question is over you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> head.
It took me many years to recognize this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same dodge by Ben. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

No, it is the WRONG question once you try >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to apply the answer to the Halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Problem, which you do. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

So the software engineering really is over >>>>>>>>>>>>>>>>>>>>>>>>>>>>> your head?
I see, so like Ben you have never actually >>>>>>>>>>>>>>>>>>>>>>>>>>>>> written any code.

But you aren't talking about Software >>>>>>>>>>>>>>>>>>>>>>>>>>>> Engineering unless you are lying about this >>>>>>>>>>>>>>>>>>>>>>>>>>>> applying to the Halting Problem described by >>>>>>>>>>>>>>>>>>>>>>>>>>>> Linz, since that is the Halting Problem of >>>>>>>>>>>>>>>>>>>>>>>>>>>> Computability Theory.

Of course, the likely explanation is that >>>>>>>>>>>>>>>>>>>>>>>>>>>> you are just ignorant of what you are >>>>>>>>>>>>>>>>>>>>>>>>>>>> talking about, so you don't understand the >>>>>>>>>>>>>>>>>>>>>>>>>>>> diference.

Ben kept masking his coding incompetence >>>>>>>>>>>>>>>>>>>>>>>>>>>>> this way.
It never occurred to me that you have never >>>>>>>>>>>>>>>>>>>>>>>>>>>>> written any code.

I have possibly written more WORKING code >>>>>>>>>>>>>>>>>>>>>>>>>>>> than you have.

I don't believe you. Your inability to answer >>>>>>>>>>>>>>>>>>>>>>>>>>> an straight forward
software engineering question seems to prove >>>>>>>>>>>>>>>>>>>>>>>>>>> otherwise.

What software engineering question? >>>>>>>>>>>>>>>>>>>>>>>>>>

Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>

The answer to that question is NO, >>>>>>>>>>>>>>>>>>>>>>>

Finally you admit an easily verified fact. >>>>>>>>>>>>>>>>>>>>>>>

but that is because H doesn't, and can never do >>>>>>>>>>>>>>>>>>>>>>>> an accurarte simulation per the definition of a >>>>>>>>>>>>>>>>>>>>>>>> UTM.

If the simulation by a UTM would be wrong then >>>>>>>>>>>>>>>>>>>>>>> you would have to be able
to point out the mistake in the simulation of D >>>>>>>>>>>>>>>>>>>>>>> by H,

No, the simulation by a ACTUAL UTM will reach a >>>>>>>>>>>>>>>>>>>>>> final state.

I don't know why you say this when you already know >>>>>>>>>>>>>>>>>>>>> that ⟨Ĥ⟩ correctly
simulated by embedded_H cannot possibly terminate >>>>>>>>>>>>>>>>>>>>> normally.

Because embedded_H doesn't actually "Correctly >>>>>>>>>>>>>>>>>>>> Simulate" its input by the definintion aquired by >>>>>>>>>>>>>>>>>>>> your mentioning of a UTM.

You have already agreed that it does simulate the >>>>>>>>>>>>>>>>>>> first N steps
correctly. It is just as obvious that the behavior >>>>>>>>>>>>>>>>>>> pattern of N steps of
⟨Ĥ⟩ correctly simulated by embedded_H cannot possibly >>>>>>>>>>>>>>>>>>> terminate normally
even if the value of N is ∞.

But N steps in not ALL steps as required by the actual >>>>>>>>>>>>>>>>>> definition of a UTM.

Actually N steps is the exact definition of a UTM for >>>>>>>>>>>>>>>>> those N steps.
Just like with the H/D example after N steps we can see >>>>>>>>>>>>>>>>> that neither
D correctly simulated by H nor ⟨Ĥ⟩ correctly simulated >>>>>>>>>>>>>>>>> by embedded_H
can possibly terminate normally.

Nope, UTMs have no concept of only doing a partial >>>>>>>>>>>>>>>> simulation.

When a simulating halt decider correctly simulates N >>>>>>>>>>>>>>> steps of its input
it derives the exact same N steps that a pure UTM would >>>>>>>>>>>>>>> derive because
it is itself a UTM with extra features.

Just like a racing car is a street legal care with extra >>>>>>>>>>>>>> features that makes it no longer street legal.

The fact that H aborts its simulation part way means it is >>>>>>>>>>>>>> no longer a UTM

*Yet only at the point where it aborts its simulation* >>>>>>>>>>>>

Right, but that affect the behavior of ALL copies of it, >>>>>>>>>>>> since they all act the same.

Do you think you are immortal because you haven't died yet, >>>>>>>>>>>> and that everyone is immortal until the point in time they die? >>>>>>>>>>>>
Since it just proves it isn't a UTM, it can't assume that >>>>>>>>>>>> the copy it is simulating is, it needs to account for that >>>>>>>>>>>> behavior.

The fact that the DESIGN logic to do this goes into an >>>>>>>>>>>> infinite loop, doesn't mean that the program itself does. >>>>>>>>>>>>
Since H aborts its simulation and returns 0, its input will >>>>>>>>>>>> see its copy do exactly the same thing and thus will Halt, >>>>>>>>>>>> making the answer wrong.

Since H isn't a UTM, since if fails to meet the defintion, >>>>>>>>>>>> the fact that it can't reach a final state is irrelevent, as >>>>>>>>>>>> is any definiton of "Correct Simulation" that differs from >>>>>>>>>>>> what a UTM does.

UTM(D,D) Halts, therefore the CORRECT SIMULATION (by a UTM >>>>>>>>>>>> which is what is allowed to replace the actual behavior of >>>>>>>>>>>> the machine) Halts, and thus the CORRECT answer is Halting. >>>>>>>>>>>>
You are just showing that you have fallen for your own >>>>>>>>>>>> Strawman Deception that got you to use the wrong criteria. >>>>>>>>>>>>

At this point where it aborts its simulation we can see >>>>>>>>>>>>> that it must
do this to prevent its own infinite execution, thus
conclusively proving
that it correctly determined that its simulated input >>>>>>>>>>>>> cannot possibly
terminate normally.

How much longer are you going to play the fool and deny this? >>>>>>>>>>>>>

No, it does so because it has been programmed to do so, and >>>>>>>>>>>> thus ALL copies of it will do so.

It makes the error assuming that the copy it is simulating >>>>>>>>>>>> will do something different than it does.

It makes no error. As you already admitted D correctly
simulated by H
cannot possibly terminate normally thus its isomorphism of >>>>>>>>>>> ⟨Ĥ⟩ correctly
simulated by embedded_H cannot possibly terminate normally. >>>>>>>>>>>
Are you going to keep playing the fool on this?

Except that you are answering the wrong question.

In other words you want to keep playing the fool and dodging >>>>>>>>> the actual question that I am actually asking.

No, you are showing yourself to be the fool by not understand
your own stupidity.

So you agreed that D correctly simulated H cannot possibly
terminate
normally and the exact same thing goes for ⟨Ĥ⟩ correctly >>>>>>>>> simulated by
embedded_H.

No, I am saying that H can not correctly simulate the input H
and give an answer. If H DOES try to correctly simulate its
input, then it can never giv an answer.

Since you already acknowledged that D correctly simulated by H
can never
terminate normally and you did not need an infinite amount of
time to
determine this then the isomorphic ⟨Ĥ⟩ correctly simulated by >>>>>>> embedded_H
can also be determined to never terminate normally and this
determination can be made in a finite amount of time.

In both cases this can be correctly determined after N steps of
simulation thus no need for the infinite simulation that you keep >>>>>>> insisting is necessary.

You keep on LYING about what I said. Any H that gives an answer
can not "Correctly Simulate" this input per the definitions that
allow simulation to replace the behavior of the actual machine.

Since you already acknowledged that D correctly simulated by H cannot >>>>> possibly terminate normally (hence [key agreement]) and the H/D
pair is
isomorphic to the embedded_H / ⟨Ĥ⟩ pair you contradict yourself. >>>>>

So?

D(D) / Ĥ (Ĥ) still halt since H returns non-halting, thus that
answer is wrong for the Halting Problem.

It only seems wrong because all of the textbooks reject simulating
halt deciders out-of-hand without review incorrectly assuming that
simulation cannot possibly be used as the basis of a halt decider:

No, it is wrong because the question asks about the actual machine,
and that halts, so the right answer is HALTING.

Yet any theory of computation computer scientist knows that a simulation
of N steps by a UTM does provide that actual behavior of the actual
input to this UTM.

Nope, only if the machine reaches a final state in that Nth Step.

You just don't understand what a UTM is or what it does.

They also know that when the input to this UTM is defined to have a pathological relationship to this UTM that this changes the behavior of
this correctly simulated input.

Nope, a UTM simulation is only correct if it exactly matches the FULL
b4ehavior of the machine it is looking at. That is its DEFINITION.

Maybe I should begin my paper with this self-evident truth before
proceeding to the notion of a simulating halt decider.

Yes, do that, so anyone who actually understand the theory knows from
that start that you are a crackpot.

In any case the perfect isomorphism between H/D and embedded_H / ⟨Ĥ⟩ already fully proves this point.

Why, since neither H or embedded_H are actually UTMs, and it is
establishied that both of them declare their input to be non-halting
when the machine they are given the description of Halt.

That just proves that you are wrong.

You are just showing that you like to call the Truth to be Lies, and
Lies to be Truth because you can't tell the difference between them
because you are a pathological liar.

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

XPost: comp.theory, sci.logic

On 5/22/23 9:33 PM, olcott wrote:

On 5/22/2023 6:22 PM, Richard Damon wrote:

On 5/22/23 10:22 AM, olcott wrote:

On 5/21/2023 2:02 PM, Richard Damon wrote:

On 5/21/23 2:50 PM, olcott wrote:

On 5/21/2023 1:39 PM, Richard Damon wrote:

On 5/21/23 2:12 PM, olcott wrote:

On 5/21/2023 11:54 AM, Richard Damon wrote:

On 5/21/23 10:16 AM, olcott wrote:

On 5/20/2023 6:52 PM, Richard Damon wrote:

On 5/20/23 5:29 PM, olcott wrote:

On 5/20/2023 4:24 PM, Richard Damon wrote:

On 5/20/23 5:10 PM, olcott wrote:

On 5/20/2023 3:48 PM, Richard Damon wrote:

On 5/20/23 4:33 PM, olcott wrote:

On 5/20/2023 2:56 PM, Richard Damon wrote:

On 5/20/23 3:29 PM, olcott wrote:

On 5/20/2023 1:54 PM, Richard Damon wrote:

On 5/20/23 2:46 PM, olcott wrote:

On 5/20/2023 1:15 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 5/20/23 1:09 PM, olcott wrote:

On 5/20/2023 11:10 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 5/20/23 11:24 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 10:19 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 10:54 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 8:49 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 12:00 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 10:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 11:00 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 9:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 8:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Wrong Question! >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

In other words the question is over you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> head.
It took me many years to recognize this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same dodge by Ben. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

No, it is the WRONG question once you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> try to apply the answer to the Halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Problem, which you do. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

So the software engineering really is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> over your head?
I see, so like Ben you have never >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually written any code. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

But you aren't talking about Software >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Engineering unless you are lying about >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this applying to the Halting Problem >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> described by Linz, since that is the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem of Computability Theory. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Of course, the likely explanation is that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are just ignorant of what you are >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> talking about, so you don't understand the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> diference.

Ben kept masking his coding incompetence >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this way.
It never occurred to me that you have >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never written any code. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

I have possibly written more WORKING code >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> than you have.

I don't believe you. Your inability to >>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer an straight forward >>>>>>>>>>>>>>>>>>>>>>>>>>>>> software engineering question seems to >>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove otherwise.

What software engineering question? >>>>>>>>>>>>>>>>>>>>>>>>>>>>

Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>

The answer to that question is NO, >>>>>>>>>>>>>>>>>>>>>>>>>

Finally you admit an easily verified fact. >>>>>>>>>>>>>>>>>>>>>>>>>

but that is because H doesn't, and can never >>>>>>>>>>>>>>>>>>>>>>>>>> do an accurarte simulation per the definition >>>>>>>>>>>>>>>>>>>>>>>>>> of a UTM.

If the simulation by a UTM would be wrong then >>>>>>>>>>>>>>>>>>>>>>>>> you would have to be able
to point out the mistake in the simulation of D >>>>>>>>>>>>>>>>>>>>>>>>> by H,

No, the simulation by a ACTUAL UTM will reach a >>>>>>>>>>>>>>>>>>>>>>>> final state.

I don't know why you say this when you already >>>>>>>>>>>>>>>>>>>>>>> know that ⟨Ĥ⟩ correctly
simulated by embedded_H cannot possibly terminate >>>>>>>>>>>>>>>>>>>>>>> normally.

Because embedded_H doesn't actually "Correctly >>>>>>>>>>>>>>>>>>>>>> Simulate" its input by the definintion aquired by >>>>>>>>>>>>>>>>>>>>>> your mentioning of a UTM.

You have already agreed that it does simulate the >>>>>>>>>>>>>>>>>>>>> first N steps
correctly. It is just as obvious that the behavior >>>>>>>>>>>>>>>>>>>>> pattern of N steps of
⟨Ĥ⟩ correctly simulated by embedded_H cannot >>>>>>>>>>>>>>>>>>>>> possibly terminate normally
even if the value of N is ∞.

But N steps in not ALL steps as required by the >>>>>>>>>>>>>>>>>>>> actual definition of a UTM.

Actually N steps is the exact definition of a UTM for >>>>>>>>>>>>>>>>>>> those N steps.
Just like with the H/D example after N steps we can >>>>>>>>>>>>>>>>>>> see that neither
D correctly simulated by H nor ⟨Ĥ⟩ correctly >>>>>>>>>>>>>>>>>>> simulated by embedded_H
can possibly terminate normally.

Nope, UTMs have no concept of only doing a partial >>>>>>>>>>>>>>>>>> simulation.

When a simulating halt decider correctly simulates N >>>>>>>>>>>>>>>>> steps of its input
it derives the exact same N steps that a pure UTM would >>>>>>>>>>>>>>>>> derive because
it is itself a UTM with extra features.

Just like a racing car is a street legal care with extra >>>>>>>>>>>>>>>> features that makes it no longer street legal. >>>>>>>>>>>>>>>>
The fact that H aborts its simulation part way means it >>>>>>>>>>>>>>>> is no longer a UTM

*Yet only at the point where it aborts its simulation* >>>>>>>>>>>>>>

Right, but that affect the behavior of ALL copies of it, >>>>>>>>>>>>>> since they all act the same.

Do you think you are immortal because you haven't died >>>>>>>>>>>>>> yet, and that everyone is immortal until the point in time >>>>>>>>>>>>>> they die?

Since it just proves it isn't a UTM, it can't assume that >>>>>>>>>>>>>> the copy it is simulating is, it needs to account for that >>>>>>>>>>>>>> behavior.

The fact that the DESIGN logic to do this goes into an >>>>>>>>>>>>>> infinite loop, doesn't mean that the program itself does. >>>>>>>>>>>>>>
Since H aborts its simulation and returns 0, its input >>>>>>>>>>>>>> will see its copy do exactly the same thing and thus will >>>>>>>>>>>>>> Halt, making the answer wrong.

Since H isn't a UTM, since if fails to meet the defintion, >>>>>>>>>>>>>> the fact that it can't reach a final state is irrelevent, >>>>>>>>>>>>>> as is any definiton of "Correct Simulation" that differs >>>>>>>>>>>>>> from what a UTM does.

UTM(D,D) Halts, therefore the CORRECT SIMULATION (by a UTM >>>>>>>>>>>>>> which is what is allowed to replace the actual behavior of >>>>>>>>>>>>>> the machine) Halts, and thus the CORRECT answer is Halting. >>>>>>>>>>>>>>
You are just showing that you have fallen for your own >>>>>>>>>>>>>> Strawman Deception that got you to use the wrong criteria. >>>>>>>>>>>>>>

At this point where it aborts its simulation we can see >>>>>>>>>>>>>>> that it must
do this to prevent its own infinite execution, thus >>>>>>>>>>>>>>> conclusively proving
that it correctly determined that its simulated input >>>>>>>>>>>>>>> cannot possibly
terminate normally.

How much longer are you going to play the fool and deny >>>>>>>>>>>>>>> this?

No, it does so because it has been programmed to do so, >>>>>>>>>>>>>> and thus ALL copies of it will do so.

It makes the error assuming that the copy it is simulating >>>>>>>>>>>>>> will do something different than it does.

It makes no error. As you already admitted D correctly >>>>>>>>>>>>> simulated by H
cannot possibly terminate normally thus its isomorphism of >>>>>>>>>>>>> ⟨Ĥ⟩ correctly
simulated by embedded_H cannot possibly terminate normally. >>>>>>>>>>>>>
Are you going to keep playing the fool on this?

Except that you are answering the wrong question.

In other words you want to keep playing the fool and dodging >>>>>>>>>>> the actual question that I am actually asking.

No, you are showing yourself to be the fool by not understand >>>>>>>>>> your own stupidity.

So you agreed that D correctly simulated H cannot possibly >>>>>>>>>>> terminate
normally and the exact same thing goes for ⟨Ĥ⟩ correctly >>>>>>>>>>> simulated by
embedded_H.

No, I am saying that H can not correctly simulate the input H >>>>>>>>>> and give an answer. If H DOES try to correctly simulate its >>>>>>>>>> input, then it can never giv an answer.

Since you already acknowledged that D correctly simulated by H >>>>>>>>> can never
terminate normally and you did not need an infinite amount of >>>>>>>>> time to
determine this then the isomorphic ⟨Ĥ⟩ correctly simulated by >>>>>>>>> embedded_H
can also be determined to never terminate normally and this
determination can be made in a finite amount of time.

In both cases this can be correctly determined after N steps of >>>>>>>>> simulation thus no need for the infinite simulation that you keep >>>>>>>>> insisting is necessary.

You keep on LYING about what I said. Any H that gives an answer >>>>>>>> can not "Correctly Simulate" this input per the definitions that >>>>>>>> allow simulation to replace the behavior of the actual machine. >>>>>>>>

Since you already acknowledged that D correctly simulated by H
cannot
possibly terminate normally (hence [key agreement]) and the H/D
pair is
isomorphic to the embedded_H / ⟨Ĥ⟩ pair you contradict yourself. >>>>>>>

So?

D(D) / Ĥ (Ĥ) still halt since H returns non-halting, thus that
answer is wrong for the Halting Problem.

It only seems wrong because all of the textbooks reject simulating
halt deciders out-of-hand without review incorrectly assuming that
simulation cannot possibly be used as the basis of a halt decider:

No, it is wrong because the question asks about the actual machine,
and that halts, so the right answer is HALTING.

Yet any theory of computation computer scientist knows that a simulation >>> of N steps by a UTM does provide that actual behavior of the actual
input to this UTM.

Nope, only if the machine reaches a final state in that Nth Step.

You just don't understand what a UTM is or what it does.

They also know that when the input to this UTM is defined to have a
pathological relationship to this UTM that this changes the behavior of
this correctly simulated input.

Nope, a UTM simulation is only correct if it exactly matches the FULL
b4ehavior of the machine it is looking at. That is its DEFINITION.

Maybe I should begin my paper with this self-evident truth before
proceeding to the notion of a simulating halt decider.

Yes, do that, so anyone who actually understand the theory knows from
that start that you are a crackpot.

In any case the perfect isomorphism between H/D and embedded_H / ⟨Ĥ⟩ >>> already fully proves this point.

Why, since neither H or embedded_H are actually UTMs, and it is
establishied that both of them declare their input to be non-halting
when the machine they are given the description of Halt.

*Clearly you are clueless about what the term isomorphism means*
Both D and ⟨Ĥ⟩ have the exact same form in that both D and ⟨Ĥ⟩ attempt to
do the opposite of whatever their corresponding halt decider determines.

Both of them loop when their halt decider returns {halts} and both halt
when their halt decider returns {non-halting}. Both of them continue to
call the halt decider in recursive simulation until their halt decider
stops simulating them.

Right, so since the Halt Decider must have a defined behavior when given
them as an input, that defined behavior will always be wrong, because no
matter how you define your H, the machines will act the other way. This
is what proves that there can't be a decider that gets all input right.

NEITHER H or embedded_H are UTM's if they answer non-halting, so the
fact that the don't reach a final state in there PARTIAL (and thus not
correct by UTM rules) simulation is irrelevant.

The ACTUAL UTM simulation of the input (which calls H) will see that it
Halts, thus, the CORRECT simulation of the input is Halting, and the one generated by your machines is shown to be NOT CORRECT by the needed
definition, it is just a PARTIAL SIMULATION, which doesn't prove
non-halting.


And actually, H/D is NOT really isomorphic to H / embedded_H to H^, as
the input to H and embedded_H is a totally distinct thing to H /
embedded_H and just contains a COPY of the input. This is a flaw in your
H/D model. D really needs to have its own copy of the code of H and be "run"/simulated in a seperate address space of the deciding H.

This is a significant change of form, that has been pointed out to you
for years, but it hasn't seemed to get through your pathological shields.

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

XPost: comp.theory, sci.logic

On 5/22/2023 6:22 PM, Richard Damon wrote:

On 5/22/23 10:22 AM, olcott wrote:

On 5/21/2023 2:02 PM, Richard Damon wrote:

On 5/21/23 2:50 PM, olcott wrote:

On 5/21/2023 1:39 PM, Richard Damon wrote:

On 5/21/23 2:12 PM, olcott wrote:

On 5/21/2023 11:54 AM, Richard Damon wrote:

On 5/21/23 10:16 AM, olcott wrote:

On 5/20/2023 6:52 PM, Richard Damon wrote:

On 5/20/23 5:29 PM, olcott wrote:

On 5/20/2023 4:24 PM, Richard Damon wrote:

On 5/20/23 5:10 PM, olcott wrote:

On 5/20/2023 3:48 PM, Richard Damon wrote:

On 5/20/23 4:33 PM, olcott wrote:

On 5/20/2023 2:56 PM, Richard Damon wrote:

On 5/20/23 3:29 PM, olcott wrote:

On 5/20/2023 1:54 PM, Richard Damon wrote:

On 5/20/23 2:46 PM, olcott wrote:

On 5/20/2023 1:15 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 5/20/23 1:09 PM, olcott wrote:

On 5/20/2023 11:10 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 5/20/23 11:24 AM, olcott wrote:

On 5/20/2023 10:19 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 10:54 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 8:49 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 12:00 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 10:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 11:00 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 9:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 8:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Wrong Question! >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

In other words the question is over you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> head.
It took me many years to recognize this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same dodge by Ben. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

No, it is the WRONG question once you try >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to apply the answer to the Halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Problem, which you do. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

So the software engineering really is over >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> your head?
I see, so like Ben you have never actually >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> written any code.

But you aren't talking about Software >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Engineering unless you are lying about this >>>>>>>>>>>>>>>>>>>>>>>>>>>>> applying to the Halting Problem described >>>>>>>>>>>>>>>>>>>>>>>>>>>>> by Linz, since that is the Halting Problem >>>>>>>>>>>>>>>>>>>>>>>>>>>>> of Computability Theory. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Of course, the likely explanation is that >>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are just ignorant of what you are >>>>>>>>>>>>>>>>>>>>>>>>>>>>> talking about, so you don't understand the >>>>>>>>>>>>>>>>>>>>>>>>>>>>> diference.

Ben kept masking his coding incompetence >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this way.
It never occurred to me that you have >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never written any code. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>

I have possibly written more WORKING code >>>>>>>>>>>>>>>>>>>>>>>>>>>>> than you have.

I don't believe you. Your inability to >>>>>>>>>>>>>>>>>>>>>>>>>>>> answer an straight forward >>>>>>>>>>>>>>>>>>>>>>>>>>>> software engineering question seems to prove >>>>>>>>>>>>>>>>>>>>>>>>>>>> otherwise.

What software engineering question? >>>>>>>>>>>>>>>>>>>>>>>>>>>

Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>

The answer to that question is NO, >>>>>>>>>>>>>>>>>>>>>>>>

Finally you admit an easily verified fact. >>>>>>>>>>>>>>>>>>>>>>>>

but that is because H doesn't, and can never do >>>>>>>>>>>>>>>>>>>>>>>>> an accurarte simulation per the definition of a >>>>>>>>>>>>>>>>>>>>>>>>> UTM.

If the simulation by a UTM would be wrong then >>>>>>>>>>>>>>>>>>>>>>>> you would have to be able
to point out the mistake in the simulation of D >>>>>>>>>>>>>>>>>>>>>>>> by H,

No, the simulation by a ACTUAL UTM will reach a >>>>>>>>>>>>>>>>>>>>>>> final state.

I don't know why you say this when you already >>>>>>>>>>>>>>>>>>>>>> know that ⟨Ĥ⟩ correctly
simulated by embedded_H cannot possibly terminate >>>>>>>>>>>>>>>>>>>>>> normally.

Because embedded_H doesn't actually "Correctly >>>>>>>>>>>>>>>>>>>>> Simulate" its input by the definintion aquired by >>>>>>>>>>>>>>>>>>>>> your mentioning of a UTM.

You have already agreed that it does simulate the >>>>>>>>>>>>>>>>>>>> first N steps
correctly. It is just as obvious that the behavior >>>>>>>>>>>>>>>>>>>> pattern of N steps of
⟨Ĥ⟩ correctly simulated by embedded_H cannot >>>>>>>>>>>>>>>>>>>> possibly terminate normally
even if the value of N is ∞.

But N steps in not ALL steps as required by the >>>>>>>>>>>>>>>>>>> actual definition of a UTM.

Actually N steps is the exact definition of a UTM for >>>>>>>>>>>>>>>>>> those N steps.
Just like with the H/D example after N steps we can >>>>>>>>>>>>>>>>>> see that neither
D correctly simulated by H nor ⟨Ĥ⟩ correctly simulated >>>>>>>>>>>>>>>>>> by embedded_H
can possibly terminate normally.

Nope, UTMs have no concept of only doing a partial >>>>>>>>>>>>>>>>> simulation.

When a simulating halt decider correctly simulates N >>>>>>>>>>>>>>>> steps of its input
it derives the exact same N steps that a pure UTM would >>>>>>>>>>>>>>>> derive because
it is itself a UTM with extra features.

Just like a racing car is a street legal care with extra >>>>>>>>>>>>>>> features that makes it no longer street legal.

The fact that H aborts its simulation part way means it >>>>>>>>>>>>>>> is no longer a UTM

*Yet only at the point where it aborts its simulation* >>>>>>>>>>>>>

Right, but that affect the behavior of ALL copies of it, >>>>>>>>>>>>> since they all act the same.

Do you think you are immortal because you haven't died yet, >>>>>>>>>>>>> and that everyone is immortal until the point in time they >>>>>>>>>>>>> die?

Since it just proves it isn't a UTM, it can't assume that >>>>>>>>>>>>> the copy it is simulating is, it needs to account for that >>>>>>>>>>>>> behavior.

The fact that the DESIGN logic to do this goes into an >>>>>>>>>>>>> infinite loop, doesn't mean that the program itself does. >>>>>>>>>>>>>
Since H aborts its simulation and returns 0, its input will >>>>>>>>>>>>> see its copy do exactly the same thing and thus will Halt, >>>>>>>>>>>>> making the answer wrong.

Since H isn't a UTM, since if fails to meet the defintion, >>>>>>>>>>>>> the fact that it can't reach a final state is irrelevent, >>>>>>>>>>>>> as is any definiton of "Correct Simulation" that differs >>>>>>>>>>>>> from what a UTM does.

UTM(D,D) Halts, therefore the CORRECT SIMULATION (by a UTM >>>>>>>>>>>>> which is what is allowed to replace the actual behavior of >>>>>>>>>>>>> the machine) Halts, and thus the CORRECT answer is Halting. >>>>>>>>>>>>>
You are just showing that you have fallen for your own >>>>>>>>>>>>> Strawman Deception that got you to use the wrong criteria. >>>>>>>>>>>>>

At this point where it aborts its simulation we can see >>>>>>>>>>>>>> that it must
do this to prevent its own infinite execution, thus >>>>>>>>>>>>>> conclusively proving
that it correctly determined that its simulated input >>>>>>>>>>>>>> cannot possibly
terminate normally.

How much longer are you going to play the fool and deny this? >>>>>>>>>>>>>>

No, it does so because it has been programmed to do so, and >>>>>>>>>>>>> thus ALL copies of it will do so.

It makes the error assuming that the copy it is simulating >>>>>>>>>>>>> will do something different than it does.

It makes no error. As you already admitted D correctly >>>>>>>>>>>> simulated by H
cannot possibly terminate normally thus its isomorphism of >>>>>>>>>>>> ⟨Ĥ⟩ correctly
simulated by embedded_H cannot possibly terminate normally. >>>>>>>>>>>>
Are you going to keep playing the fool on this?

Except that you are answering the wrong question.

In other words you want to keep playing the fool and dodging >>>>>>>>>> the actual question that I am actually asking.

No, you are showing yourself to be the fool by not understand >>>>>>>>> your own stupidity.

So you agreed that D correctly simulated H cannot possibly >>>>>>>>>> terminate
normally and the exact same thing goes for ⟨Ĥ⟩ correctly >>>>>>>>>> simulated by
embedded_H.

No, I am saying that H can not correctly simulate the input H >>>>>>>>> and give an answer. If H DOES try to correctly simulate its
input, then it can never giv an answer.

Since you already acknowledged that D correctly simulated by H >>>>>>>> can never
terminate normally and you did not need an infinite amount of
time to
determine this then the isomorphic ⟨Ĥ⟩ correctly simulated by >>>>>>>> embedded_H
can also be determined to never terminate normally and this
determination can be made in a finite amount of time.

In both cases this can be correctly determined after N steps of >>>>>>>> simulation thus no need for the infinite simulation that you keep >>>>>>>> insisting is necessary.

You keep on LYING about what I said. Any H that gives an answer
can not "Correctly Simulate" this input per the definitions that >>>>>>> allow simulation to replace the behavior of the actual machine.

Since you already acknowledged that D correctly simulated by H cannot >>>>>> possibly terminate normally (hence [key agreement]) and the H/D
pair is
isomorphic to the embedded_H / ⟨Ĥ⟩ pair you contradict yourself. >>>>>>

So?

D(D) / Ĥ (Ĥ) still halt since H returns non-halting, thus that
answer is wrong for the Halting Problem.

It only seems wrong because all of the textbooks reject simulating
halt deciders out-of-hand without review incorrectly assuming that
simulation cannot possibly be used as the basis of a halt decider:

No, it is wrong because the question asks about the actual machine,
and that halts, so the right answer is HALTING.

Yet any theory of computation computer scientist knows that a simulation
of N steps by a UTM does provide that actual behavior of the actual
input to this UTM.

Nope, only if the machine reaches a final state in that Nth Step.

You just don't understand what a UTM is or what it does.

They also know that when the input to this UTM is defined to have a
pathological relationship to this UTM that this changes the behavior of
this correctly simulated input.

Nope, a UTM simulation is only correct if it exactly matches the FULL b4ehavior of the machine it is looking at. That is its DEFINITION.

Maybe I should begin my paper with this self-evident truth before
proceeding to the notion of a simulating halt decider.

Yes, do that, so anyone who actually understand the theory knows from
that start that you are a crackpot.

In any case the perfect isomorphism between H/D and embedded_H / ⟨Ĥ⟩
already fully proves this point.

Why, since neither H or embedded_H are actually UTMs, and it is
establishied that both of them declare their input to be non-halting
when the machine they are given the description of Halt.

*Clearly you are clueless about what the term isomorphism means*
Both D and ⟨Ĥ⟩ have the exact same form in that both D and ⟨Ĥ⟩ attempt to
do the opposite of whatever their corresponding halt decider determines.

Both of them loop when their halt decider returns {halts} and both halt
when their halt decider returns {non-halting}. Both of them continue to
call the halt decider in recursive simulation until their halt decider
stops simulating them.

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

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

XPost: comp.theory, sci.logic

On 5/22/2023 9:02 PM, Richard Damon wrote:

On 5/22/23 9:33 PM, olcott wrote:

On 5/22/2023 6:22 PM, Richard Damon wrote:

On 5/22/23 10:22 AM, olcott wrote:

On 5/21/2023 2:02 PM, Richard Damon wrote:

On 5/21/23 2:50 PM, olcott wrote:

On 5/21/2023 1:39 PM, Richard Damon wrote:

On 5/21/23 2:12 PM, olcott wrote:

On 5/21/2023 11:54 AM, Richard Damon wrote:

On 5/21/23 10:16 AM, olcott wrote:

On 5/20/2023 6:52 PM, Richard Damon wrote:

On 5/20/23 5:29 PM, olcott wrote:

On 5/20/2023 4:24 PM, Richard Damon wrote:

On 5/20/23 5:10 PM, olcott wrote:

On 5/20/2023 3:48 PM, Richard Damon wrote:

On 5/20/23 4:33 PM, olcott wrote:

On 5/20/2023 2:56 PM, Richard Damon wrote:

On 5/20/23 3:29 PM, olcott wrote:

On 5/20/2023 1:54 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 5/20/23 2:46 PM, olcott wrote:

On 5/20/2023 1:15 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 5/20/23 1:09 PM, olcott wrote:

On 5/20/2023 11:10 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 11:24 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 10:19 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 10:54 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 8:49 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 12:00 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 10:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 11:00 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 9:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 8:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:

On 5/19/23 10:50 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Wrong Question! >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

In other words the question is over >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you head.
It took me many years to recognize >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this same dodge by Ben. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

No, it is the WRONG question once you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> try to apply the answer to the Halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Problem, which you do. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

So the software engineering really is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> over your head? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I see, so like Ben you have never >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually written any code. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

But you aren't talking about Software >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Engineering unless you are lying about >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this applying to the Halting Problem >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> described by Linz, since that is the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem of Computability Theory. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Of course, the likely explanation is that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are just ignorant of what you are >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> talking about, so you don't understand >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the diference.

Ben kept masking his coding incompetence >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this way.
It never occurred to me that you have >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never written any code. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

I have possibly written more WORKING code >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> than you have.

I don't believe you. Your inability to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer an straight forward >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> software engineering question seems to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove otherwise.

What software engineering question? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>

The answer to that question is NO, >>>>>>>>>>>>>>>>>>>>>>>>>>

Finally you admit an easily verified fact. >>>>>>>>>>>>>>>>>>>>>>>>>>

but that is because H doesn't, and can never >>>>>>>>>>>>>>>>>>>>>>>>>>> do an accurarte simulation per the definition >>>>>>>>>>>>>>>>>>>>>>>>>>> of a UTM.

If the simulation by a UTM would be wrong then >>>>>>>>>>>>>>>>>>>>>>>>>> you would have to be able
to point out the mistake in the simulation of >>>>>>>>>>>>>>>>>>>>>>>>>> D by H,

No, the simulation by a ACTUAL UTM will reach a >>>>>>>>>>>>>>>>>>>>>>>>> final state.

I don't know why you say this when you already >>>>>>>>>>>>>>>>>>>>>>>> know that ⟨Ĥ⟩ correctly
simulated by embedded_H cannot possibly >>>>>>>>>>>>>>>>>>>>>>>> terminate normally.

Because embedded_H doesn't actually "Correctly >>>>>>>>>>>>>>>>>>>>>>> Simulate" its input by the definintion aquired by >>>>>>>>>>>>>>>>>>>>>>> your mentioning of a UTM.

You have already agreed that it does simulate the >>>>>>>>>>>>>>>>>>>>>> first N steps
correctly. It is just as obvious that the behavior >>>>>>>>>>>>>>>>>>>>>> pattern of N steps of
⟨Ĥ⟩ correctly simulated by embedded_H cannot >>>>>>>>>>>>>>>>>>>>>> possibly terminate normally
even if the value of N is ∞.

But N steps in not ALL steps as required by the >>>>>>>>>>>>>>>>>>>>> actual definition of a UTM.

Actually N steps is the exact definition of a UTM >>>>>>>>>>>>>>>>>>>> for those N steps.
Just like with the H/D example after N steps we can >>>>>>>>>>>>>>>>>>>> see that neither
D correctly simulated by H nor ⟨Ĥ⟩ correctly >>>>>>>>>>>>>>>>>>>> simulated by embedded_H
can possibly terminate normally.

Nope, UTMs have no concept of only doing a partial >>>>>>>>>>>>>>>>>>> simulation.

When a simulating halt decider correctly simulates N >>>>>>>>>>>>>>>>>> steps of its input
it derives the exact same N steps that a pure UTM >>>>>>>>>>>>>>>>>> would derive because
it is itself a UTM with extra features.

Just like a racing car is a street legal care with >>>>>>>>>>>>>>>>> extra features that makes it no longer street legal. >>>>>>>>>>>>>>>>>
The fact that H aborts its simulation part way means it >>>>>>>>>>>>>>>>> is no longer a UTM

*Yet only at the point where it aborts its simulation* >>>>>>>>>>>>>>>

Right, but that affect the behavior of ALL copies of it, >>>>>>>>>>>>>>> since they all act the same.

Do you think you are immortal because you haven't died >>>>>>>>>>>>>>> yet, and that everyone is immortal until the point in >>>>>>>>>>>>>>> time they die?

Since it just proves it isn't a UTM, it can't assume that >>>>>>>>>>>>>>> the copy it is simulating is, it needs to account for >>>>>>>>>>>>>>> that behavior.

The fact that the DESIGN logic to do this goes into an >>>>>>>>>>>>>>> infinite loop, doesn't mean that the program itself does. >>>>>>>>>>>>>>>
Since H aborts its simulation and returns 0, its input >>>>>>>>>>>>>>> will see its copy do exactly the same thing and thus will >>>>>>>>>>>>>>> Halt, making the answer wrong.

Since H isn't a UTM, since if fails to meet the
defintion, the fact that it can't reach a final state is >>>>>>>>>>>>>>> irrelevent, as is any definiton of "Correct Simulation" >>>>>>>>>>>>>>> that differs from what a UTM does.

UTM(D,D) Halts, therefore the CORRECT SIMULATION (by a >>>>>>>>>>>>>>> UTM which is what is allowed to replace the actual >>>>>>>>>>>>>>> behavior of the machine) Halts, and thus the CORRECT >>>>>>>>>>>>>>> answer is Halting.

You are just showing that you have fallen for your own >>>>>>>>>>>>>>> Strawman Deception that got you to use the wrong criteria. >>>>>>>>>>>>>>>

At this point where it aborts its simulation we can see >>>>>>>>>>>>>>>> that it must
do this to prevent its own infinite execution, thus >>>>>>>>>>>>>>>> conclusively proving
that it correctly determined that its simulated input >>>>>>>>>>>>>>>> cannot possibly
terminate normally.

How much longer are you going to play the fool and deny >>>>>>>>>>>>>>>> this?

No, it does so because it has been programmed to do so, >>>>>>>>>>>>>>> and thus ALL copies of it will do so.

It makes the error assuming that the copy it is
simulating will do something different than it does. >>>>>>>>>>>>>>

It makes no error. As you already admitted D correctly >>>>>>>>>>>>>> simulated by H
cannot possibly terminate normally thus its isomorphism of >>>>>>>>>>>>>> ⟨Ĥ⟩ correctly
simulated by embedded_H cannot possibly terminate normally. >>>>>>>>>>>>>>
Are you going to keep playing the fool on this?

Except that you are answering the wrong question.

In other words you want to keep playing the fool and dodging >>>>>>>>>>>> the actual question that I am actually asking.

No, you are showing yourself to be the fool by not understand >>>>>>>>>>> your own stupidity.

So you agreed that D correctly simulated H cannot possibly >>>>>>>>>>>> terminate
normally and the exact same thing goes for ⟨Ĥ⟩ correctly >>>>>>>>>>>> simulated by
embedded_H.

No, I am saying that H can not correctly simulate the input H >>>>>>>>>>> and give an answer. If H DOES try to correctly simulate its >>>>>>>>>>> input, then it can never giv an answer.

Since you already acknowledged that D correctly simulated by H >>>>>>>>>> can never
terminate normally and you did not need an infinite amount of >>>>>>>>>> time to
determine this then the isomorphic ⟨Ĥ⟩ correctly simulated by >>>>>>>>>> embedded_H
can also be determined to never terminate normally and this >>>>>>>>>> determination can be made in a finite amount of time.

In both cases this can be correctly determined after N steps of >>>>>>>>>> simulation thus no need for the infinite simulation that you keep >>>>>>>>>> insisting is necessary.

You keep on LYING about what I said. Any H that gives an answer >>>>>>>>> can not "Correctly Simulate" this input per the definitions
that allow simulation to replace the behavior of the actual
machine.

Since you already acknowledged that D correctly simulated by H >>>>>>>> cannot
possibly terminate normally (hence [key agreement]) and the H/D >>>>>>>> pair is
isomorphic to the embedded_H / ⟨Ĥ⟩ pair you contradict yourself. >>>>>>>>

So?

D(D) / Ĥ (Ĥ) still halt since H returns non-halting, thus that >>>>>>> answer is wrong for the Halting Problem.

It only seems wrong because all of the textbooks reject simulating >>>>>> halt deciders out-of-hand without review incorrectly assuming that >>>>>> simulation cannot possibly be used as the basis of a halt decider:

No, it is wrong because the question asks about the actual machine,
and that halts, so the right answer is HALTING.

Yet any theory of computation computer scientist knows that a
simulation
of N steps by a UTM does provide that actual behavior of the actual
input to this UTM.

Nope, only if the machine reaches a final state in that Nth Step.

You just don't understand what a UTM is or what it does.

They also know that when the input to this UTM is defined to have a
pathological relationship to this UTM that this changes the behavior of >>>> this correctly simulated input.

Nope, a UTM simulation is only correct if it exactly matches the FULL
b4ehavior of the machine it is looking at. That is its DEFINITION.

Maybe I should begin my paper with this self-evident truth before
proceeding to the notion of a simulating halt decider.

Yes, do that, so anyone who actually understand the theory knows from
that start that you are a crackpot.

In any case the perfect isomorphism between H/D and embedded_H / ⟨Ĥ⟩ >>>> already fully proves this point.

Why, since neither H or embedded_H are actually UTMs, and it is
establishied that both of them declare their input to be non-halting
when the machine they are given the description of Halt.

*Clearly you are clueless about what the term isomorphism means*
Both D and ⟨Ĥ⟩ have the exact same form in that both D and ⟨Ĥ⟩ attempt to
do the opposite of whatever their corresponding halt decider determines.

Both of them loop when their halt decider returns {halts} and both halt
when their halt decider returns {non-halting}. Both of them continue to
call the halt decider in recursive simulation until their halt decider
stops simulating them.

Right, so since the Halt Decider must have a defined behavior when given
them as an input, that defined behavior will always be wrong, because no matter how you define your H, the machines will act the other way. This
is what proves that there can't be a decider that gets all input right.

I did not say that precisely enough.

Both of the simulated inputs [WOULD] loop if their corresponding halt
decider [WOULD] return {halts} to them and [WOULD] halt loop if their corresponding halt decider [WOULD] return {non-halting} to them yet the
actual case is that they remain stuck in recursive simulation until
their corresponding halt decider stops simulating them.

Thus as you admitted for the H/D pair also applies to the
embedded_H / ⟨Ĥ⟩ pair. The simulated input cannot possibly terminate normally because it remains stuck in recursive simulation until the
simulation is terminated *IN BOTH CASES*



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

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

XPost: comp.theory, sci.logic

On 5/22/2023 9:27 PM, olcott wrote:

On 5/22/2023 9:02 PM, Richard Damon wrote:

On 5/22/23 9:33 PM, olcott wrote:

On 5/22/2023 6:22 PM, Richard Damon wrote:

On 5/22/23 10:22 AM, olcott wrote:

On 5/21/2023 2:02 PM, Richard Damon wrote:

On 5/21/23 2:50 PM, olcott wrote:

On 5/21/2023 1:39 PM, Richard Damon wrote:

On 5/21/23 2:12 PM, olcott wrote:

On 5/21/2023 11:54 AM, Richard Damon wrote:

On 5/21/23 10:16 AM, olcott wrote:

On 5/20/2023 6:52 PM, Richard Damon wrote:

On 5/20/23 5:29 PM, olcott wrote:

On 5/20/2023 4:24 PM, Richard Damon wrote:

On 5/20/23 5:10 PM, olcott wrote:

On 5/20/2023 3:48 PM, Richard Damon wrote:

On 5/20/23 4:33 PM, olcott wrote:

On 5/20/2023 2:56 PM, Richard Damon wrote:

On 5/20/23 3:29 PM, olcott wrote:

On 5/20/2023 1:54 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 5/20/23 2:46 PM, olcott wrote:

On 5/20/2023 1:15 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 5/20/23 1:09 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 11:10 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 11:24 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 10:19 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 10:54 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 8:49 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 12:00 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 10:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 11:00 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 9:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 8:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:

On 5/19/23 10:50 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Wrong Question! >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

In other words the question is over >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you head. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It took me many years to recognize >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this same dodge by Ben. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

No, it is the WRONG question once you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> try to apply the answer to the Halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Problem, which you do. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

So the software engineering really is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> over your head? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I see, so like Ben you have never >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually written any code. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

But you aren't talking about Software >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Engineering unless you are lying about >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this applying to the Halting Problem >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> described by Linz, since that is the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem of Computability Theory. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Of course, the likely explanation is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you are just ignorant of what you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are talking about, so you don't >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand the diference. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Ben kept masking his coding >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incompetence this way. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It never occurred to me that you have >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never written any code. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

I have possibly written more WORKING >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> code than you have. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

I don't believe you. Your inability to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer an straight forward >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> software engineering question seems to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove otherwise.

What software engineering question? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>

The answer to that question is NO, >>>>>>>>>>>>>>>>>>>>>>>>>>>

Finally you admit an easily verified fact. >>>>>>>>>>>>>>>>>>>>>>>>>>>

but that is because H doesn't, and can never >>>>>>>>>>>>>>>>>>>>>>>>>>>> do an accurarte simulation per the >>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a UTM.

If the simulation by a UTM would be wrong >>>>>>>>>>>>>>>>>>>>>>>>>>> then you would have to be able >>>>>>>>>>>>>>>>>>>>>>>>>>> to point out the mistake in the simulation of >>>>>>>>>>>>>>>>>>>>>>>>>>> D by H,

No, the simulation by a ACTUAL UTM will reach >>>>>>>>>>>>>>>>>>>>>>>>>> a final state.

I don't know why you say this when you already >>>>>>>>>>>>>>>>>>>>>>>>> know that ⟨Ĥ⟩ correctly >>>>>>>>>>>>>>>>>>>>>>>>> simulated by embedded_H cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>> terminate normally.

Because embedded_H doesn't actually "Correctly >>>>>>>>>>>>>>>>>>>>>>>> Simulate" its input by the definintion aquired >>>>>>>>>>>>>>>>>>>>>>>> by your mentioning of a UTM.

You have already agreed that it does simulate the >>>>>>>>>>>>>>>>>>>>>>> first N steps
correctly. It is just as obvious that the >>>>>>>>>>>>>>>>>>>>>>> behavior pattern of N steps of
⟨Ĥ⟩ correctly simulated by embedded_H cannot >>>>>>>>>>>>>>>>>>>>>>> possibly terminate normally
even if the value of N is ∞.

But N steps in not ALL steps as required by the >>>>>>>>>>>>>>>>>>>>>> actual definition of a UTM.

Actually N steps is the exact definition of a UTM >>>>>>>>>>>>>>>>>>>>> for those N steps.
Just like with the H/D example after N steps we can >>>>>>>>>>>>>>>>>>>>> see that neither
D correctly simulated by H nor ⟨Ĥ⟩ correctly >>>>>>>>>>>>>>>>>>>>> simulated by embedded_H
can possibly terminate normally.

Nope, UTMs have no concept of only doing a partial >>>>>>>>>>>>>>>>>>>> simulation.

When a simulating halt decider correctly simulates N >>>>>>>>>>>>>>>>>>> steps of its input
it derives the exact same N steps that a pure UTM >>>>>>>>>>>>>>>>>>> would derive because
it is itself a UTM with extra features.

Just like a racing car is a street legal care with >>>>>>>>>>>>>>>>>> extra features that makes it no longer street legal. >>>>>>>>>>>>>>>>>>
The fact that H aborts its simulation part way means >>>>>>>>>>>>>>>>>> it is no longer a UTM

*Yet only at the point where it aborts its simulation* >>>>>>>>>>>>>>>>

Right, but that affect the behavior of ALL copies of it, >>>>>>>>>>>>>>>> since they all act the same.

Do you think you are immortal because you haven't died >>>>>>>>>>>>>>>> yet, and that everyone is immortal until the point in >>>>>>>>>>>>>>>> time they die?

Since it just proves it isn't a UTM, it can't assume >>>>>>>>>>>>>>>> that the copy it is simulating is, it needs to account >>>>>>>>>>>>>>>> for that behavior.

The fact that the DESIGN logic to do this goes into an >>>>>>>>>>>>>>>> infinite loop, doesn't mean that the program itself does. >>>>>>>>>>>>>>>>
Since H aborts its simulation and returns 0, its input >>>>>>>>>>>>>>>> will see its copy do exactly the same thing and thus >>>>>>>>>>>>>>>> will Halt, making the answer wrong.

Since H isn't a UTM, since if fails to meet the >>>>>>>>>>>>>>>> defintion, the fact that it can't reach a final state is >>>>>>>>>>>>>>>> irrelevent, as is any definiton of "Correct Simulation" >>>>>>>>>>>>>>>> that differs from what a UTM does.

UTM(D,D) Halts, therefore the CORRECT SIMULATION (by a >>>>>>>>>>>>>>>> UTM which is what is allowed to replace the actual >>>>>>>>>>>>>>>> behavior of the machine) Halts, and thus the CORRECT >>>>>>>>>>>>>>>> answer is Halting.

You are just showing that you have fallen for your own >>>>>>>>>>>>>>>> Strawman Deception that got you to use the wrong criteria. >>>>>>>>>>>>>>>>

At this point where it aborts its simulation we can see >>>>>>>>>>>>>>>>> that it must
do this to prevent its own infinite execution, thus >>>>>>>>>>>>>>>>> conclusively proving
that it correctly determined that its simulated input >>>>>>>>>>>>>>>>> cannot possibly
terminate normally.

How much longer are you going to play the fool and deny >>>>>>>>>>>>>>>>> this?

No, it does so because it has been programmed to do so, >>>>>>>>>>>>>>>> and thus ALL copies of it will do so.

It makes the error assuming that the copy it is >>>>>>>>>>>>>>>> simulating will do something different than it does. >>>>>>>>>>>>>>>

It makes no error. As you already admitted D correctly >>>>>>>>>>>>>>> simulated by H
cannot possibly terminate normally thus its isomorphism >>>>>>>>>>>>>>> of ⟨Ĥ⟩ correctly
simulated by embedded_H cannot possibly terminate normally. >>>>>>>>>>>>>>>
Are you going to keep playing the fool on this?

Except that you are answering the wrong question.

In other words you want to keep playing the fool and >>>>>>>>>>>>> dodging the actual question that I am actually asking. >>>>>>>>>>>>

No, you are showing yourself to be the fool by not
understand your own stupidity.

So you agreed that D correctly simulated H cannot possibly >>>>>>>>>>>>> terminate
normally and the exact same thing goes for ⟨Ĥ⟩ correctly >>>>>>>>>>>>> simulated by
embedded_H.

No, I am saying that H can not correctly simulate the input >>>>>>>>>>>> H and give an answer. If H DOES try to correctly simulate >>>>>>>>>>>> its input, then it can never giv an answer.

Since you already acknowledged that D correctly simulated by >>>>>>>>>>> H can never
terminate normally and you did not need an infinite amount of >>>>>>>>>>> time to
determine this then the isomorphic ⟨Ĥ⟩ correctly simulated by >>>>>>>>>>> embedded_H
can also be determined to never terminate normally and this >>>>>>>>>>> determination can be made in a finite amount of time.

In both cases this can be correctly determined after N steps of >>>>>>>>>>> simulation thus no need for the infinite simulation that you >>>>>>>>>>> keep
insisting is necessary.

You keep on LYING about what I said. Any H that gives an
answer can not "Correctly Simulate" this input per the
definitions that allow simulation to replace the behavior of >>>>>>>>>> the actual machine.

Since you already acknowledged that D correctly simulated by H >>>>>>>>> cannot
possibly terminate normally (hence [key agreement]) and the H/D >>>>>>>>> pair is
isomorphic to the embedded_H / ⟨Ĥ⟩ pair you contradict yourself. >>>>>>>>>

So?

D(D) / Ĥ (Ĥ) still halt since H returns non-halting, thus that >>>>>>>> answer is wrong for the Halting Problem.

It only seems wrong because all of the textbooks reject simulating >>>>>>> halt deciders out-of-hand without review incorrectly assuming that >>>>>>> simulation cannot possibly be used as the basis of a halt decider: >>>>>>

No, it is wrong because the question asks about the actual
machine, and that halts, so the right answer is HALTING.

Yet any theory of computation computer scientist knows that a
simulation
of N steps by a UTM does provide that actual behavior of the actual
input to this UTM.

Nope, only if the machine reaches a final state in that Nth Step.

You just don't understand what a UTM is or what it does.

They also know that when the input to this UTM is defined to have a
pathological relationship to this UTM that this changes the
behavior of
this correctly simulated input.

Nope, a UTM simulation is only correct if it exactly matches the
FULL b4ehavior of the machine it is looking at. That is its DEFINITION. >>>>

Maybe I should begin my paper with this self-evident truth before
proceeding to the notion of a simulating halt decider.

Yes, do that, so anyone who actually understand the theory knows
from that start that you are a crackpot.

In any case the perfect isomorphism between H/D and embedded_H / ⟨Ĥ⟩ >>>>> already fully proves this point.

Why, since neither H or embedded_H are actually UTMs, and it is
establishied that both of them declare their input to be non-halting
when the machine they are given the description of Halt.

*Clearly you are clueless about what the term isomorphism means*
Both D and ⟨Ĥ⟩ have the exact same form in that both D and ⟨Ĥ⟩ >>> attempt to
do the opposite of whatever their corresponding halt decider determines. >>>
Both of them loop when their halt decider returns {halts} and both halt
when their halt decider returns {non-halting}. Both of them continue to
call the halt decider in recursive simulation until their halt decider
stops simulating them.

Right, so since the Halt Decider must have a defined behavior when
given them as an input, that defined behavior will always be wrong,
because no matter how you define your H, the machines will act the
other way. This is what proves that there can't be a decider that gets
all input right.

I did not say that precisely enough.

Both of the simulated inputs [WOULD] loop if their corresponding halt
decider [WOULD] return {halts} to them and [WOULD] halt loop if their corresponding halt decider [WOULD] return {non-halting} to them yet the actual case is that they remain stuck in recursive simulation until
their corresponding halt decider stops simulating them.

Thus as you admitted for the H/D pair also applies to the
embedded_H / ⟨Ĥ⟩ pair. The simulated input cannot possibly terminate normally because it remains stuck in recursive simulation until the simulation is terminated *IN BOTH CASES*

You seem to be acting like the HBO Westworld character Bernard that was
a robot (AKA host) was almost perfectly a very smart human except that
his brain was hard-wired to not be able to "see" a specific door.

Then, once they're inside the dark house where Ford's robotic family
lives, Theresa asks what's behind one of the doors. "What door?" Bernard
asks, and that's when you know he's a host as well. The door is plain as
day, even in the dark, and he's been there before. And yet, he couldn't
see it.

https://www.forbes.com/sites/erikkain/2016/11/14/one-of-the-biggest-westworld-fan-theories-just-came-true/?sh=5bcd83a38a3e

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

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

XPost: comp.theory, sci.logic

On 5/22/23 10:27 PM, olcott wrote:

On 5/22/2023 9:02 PM, Richard Damon wrote:

On 5/22/23 9:33 PM, olcott wrote:

On 5/22/2023 6:22 PM, Richard Damon wrote:

On 5/22/23 10:22 AM, olcott wrote:

On 5/21/2023 2:02 PM, Richard Damon wrote:

On 5/21/23 2:50 PM, olcott wrote:

On 5/21/2023 1:39 PM, Richard Damon wrote:

On 5/21/23 2:12 PM, olcott wrote:

On 5/21/2023 11:54 AM, Richard Damon wrote:

On 5/21/23 10:16 AM, olcott wrote:

On 5/20/2023 6:52 PM, Richard Damon wrote:

On 5/20/23 5:29 PM, olcott wrote:

On 5/20/2023 4:24 PM, Richard Damon wrote:

On 5/20/23 5:10 PM, olcott wrote:

On 5/20/2023 3:48 PM, Richard Damon wrote:

On 5/20/23 4:33 PM, olcott wrote:

On 5/20/2023 2:56 PM, Richard Damon wrote:

On 5/20/23 3:29 PM, olcott wrote:

On 5/20/2023 1:54 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 5/20/23 2:46 PM, olcott wrote:

On 5/20/2023 1:15 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 5/20/23 1:09 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 11:10 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 11:24 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 10:19 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 10:54 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 8:49 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 12:00 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 10:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 11:00 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 9:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 8:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:

On 5/19/23 10:50 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Wrong Question! >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

In other words the question is over >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you head. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It took me many years to recognize >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this same dodge by Ben. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

No, it is the WRONG question once you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> try to apply the answer to the Halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Problem, which you do. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

So the software engineering really is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> over your head? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I see, so like Ben you have never >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually written any code. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

But you aren't talking about Software >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Engineering unless you are lying about >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this applying to the Halting Problem >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> described by Linz, since that is the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem of Computability Theory. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Of course, the likely explanation is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you are just ignorant of what you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are talking about, so you don't >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand the diference. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Ben kept masking his coding >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incompetence this way. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It never occurred to me that you have >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never written any code. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

I have possibly written more WORKING >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> code than you have. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

I don't believe you. Your inability to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer an straight forward >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> software engineering question seems to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove otherwise.

What software engineering question? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>

The answer to that question is NO, >>>>>>>>>>>>>>>>>>>>>>>>>>>

Finally you admit an easily verified fact. >>>>>>>>>>>>>>>>>>>>>>>>>>>

but that is because H doesn't, and can never >>>>>>>>>>>>>>>>>>>>>>>>>>>> do an accurarte simulation per the >>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a UTM.

If the simulation by a UTM would be wrong >>>>>>>>>>>>>>>>>>>>>>>>>>> then you would have to be able >>>>>>>>>>>>>>>>>>>>>>>>>>> to point out the mistake in the simulation of >>>>>>>>>>>>>>>>>>>>>>>>>>> D by H,

No, the simulation by a ACTUAL UTM will reach >>>>>>>>>>>>>>>>>>>>>>>>>> a final state.

I don't know why you say this when you already >>>>>>>>>>>>>>>>>>>>>>>>> know that ⟨Ĥ⟩ correctly >>>>>>>>>>>>>>>>>>>>>>>>> simulated by embedded_H cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>> terminate normally.

Because embedded_H doesn't actually "Correctly >>>>>>>>>>>>>>>>>>>>>>>> Simulate" its input by the definintion aquired >>>>>>>>>>>>>>>>>>>>>>>> by your mentioning of a UTM.

You have already agreed that it does simulate the >>>>>>>>>>>>>>>>>>>>>>> first N steps
correctly. It is just as obvious that the >>>>>>>>>>>>>>>>>>>>>>> behavior pattern of N steps of
⟨Ĥ⟩ correctly simulated by embedded_H cannot >>>>>>>>>>>>>>>>>>>>>>> possibly terminate normally
even if the value of N is ∞.

But N steps in not ALL steps as required by the >>>>>>>>>>>>>>>>>>>>>> actual definition of a UTM.

Actually N steps is the exact definition of a UTM >>>>>>>>>>>>>>>>>>>>> for those N steps.
Just like with the H/D example after N steps we can >>>>>>>>>>>>>>>>>>>>> see that neither
D correctly simulated by H nor ⟨Ĥ⟩ correctly >>>>>>>>>>>>>>>>>>>>> simulated by embedded_H
can possibly terminate normally.

Nope, UTMs have no concept of only doing a partial >>>>>>>>>>>>>>>>>>>> simulation.

When a simulating halt decider correctly simulates N >>>>>>>>>>>>>>>>>>> steps of its input
it derives the exact same N steps that a pure UTM >>>>>>>>>>>>>>>>>>> would derive because
it is itself a UTM with extra features.

Just like a racing car is a street legal care with >>>>>>>>>>>>>>>>>> extra features that makes it no longer street legal. >>>>>>>>>>>>>>>>>>
The fact that H aborts its simulation part way means >>>>>>>>>>>>>>>>>> it is no longer a UTM

*Yet only at the point where it aborts its simulation* >>>>>>>>>>>>>>>>

Right, but that affect the behavior of ALL copies of it, >>>>>>>>>>>>>>>> since they all act the same.

Do you think you are immortal because you haven't died >>>>>>>>>>>>>>>> yet, and that everyone is immortal until the point in >>>>>>>>>>>>>>>> time they die?

Since it just proves it isn't a UTM, it can't assume >>>>>>>>>>>>>>>> that the copy it is simulating is, it needs to account >>>>>>>>>>>>>>>> for that behavior.

The fact that the DESIGN logic to do this goes into an >>>>>>>>>>>>>>>> infinite loop, doesn't mean that the program itself does. >>>>>>>>>>>>>>>>
Since H aborts its simulation and returns 0, its input >>>>>>>>>>>>>>>> will see its copy do exactly the same thing and thus >>>>>>>>>>>>>>>> will Halt, making the answer wrong.

Since H isn't a UTM, since if fails to meet the >>>>>>>>>>>>>>>> defintion, the fact that it can't reach a final state is >>>>>>>>>>>>>>>> irrelevent, as is any definiton of "Correct Simulation" >>>>>>>>>>>>>>>> that differs from what a UTM does.

UTM(D,D) Halts, therefore the CORRECT SIMULATION (by a >>>>>>>>>>>>>>>> UTM which is what is allowed to replace the actual >>>>>>>>>>>>>>>> behavior of the machine) Halts, and thus the CORRECT >>>>>>>>>>>>>>>> answer is Halting.

You are just showing that you have fallen for your own >>>>>>>>>>>>>>>> Strawman Deception that got you to use the wrong criteria. >>>>>>>>>>>>>>>>

At this point where it aborts its simulation we can see >>>>>>>>>>>>>>>>> that it must
do this to prevent its own infinite execution, thus >>>>>>>>>>>>>>>>> conclusively proving
that it correctly determined that its simulated input >>>>>>>>>>>>>>>>> cannot possibly
terminate normally.

How much longer are you going to play the fool and deny >>>>>>>>>>>>>>>>> this?

No, it does so because it has been programmed to do so, >>>>>>>>>>>>>>>> and thus ALL copies of it will do so.

It makes the error assuming that the copy it is >>>>>>>>>>>>>>>> simulating will do something different than it does. >>>>>>>>>>>>>>>

It makes no error. As you already admitted D correctly >>>>>>>>>>>>>>> simulated by H
cannot possibly terminate normally thus its isomorphism >>>>>>>>>>>>>>> of ⟨Ĥ⟩ correctly
simulated by embedded_H cannot possibly terminate normally. >>>>>>>>>>>>>>>
Are you going to keep playing the fool on this?

Except that you are answering the wrong question.

In other words you want to keep playing the fool and >>>>>>>>>>>>> dodging the actual question that I am actually asking. >>>>>>>>>>>>

No, you are showing yourself to be the fool by not
understand your own stupidity.

So you agreed that D correctly simulated H cannot possibly >>>>>>>>>>>>> terminate
normally and the exact same thing goes for ⟨Ĥ⟩ correctly >>>>>>>>>>>>> simulated by
embedded_H.

No, I am saying that H can not correctly simulate the input >>>>>>>>>>>> H and give an answer. If H DOES try to correctly simulate >>>>>>>>>>>> its input, then it can never giv an answer.

Since you already acknowledged that D correctly simulated by >>>>>>>>>>> H can never
terminate normally and you did not need an infinite amount of >>>>>>>>>>> time to
determine this then the isomorphic ⟨Ĥ⟩ correctly simulated by >>>>>>>>>>> embedded_H
can also be determined to never terminate normally and this >>>>>>>>>>> determination can be made in a finite amount of time.

In both cases this can be correctly determined after N steps of >>>>>>>>>>> simulation thus no need for the infinite simulation that you >>>>>>>>>>> keep
insisting is necessary.

You keep on LYING about what I said. Any H that gives an
answer can not "Correctly Simulate" this input per the
definitions that allow simulation to replace the behavior of >>>>>>>>>> the actual machine.

Since you already acknowledged that D correctly simulated by H >>>>>>>>> cannot
possibly terminate normally (hence [key agreement]) and the H/D >>>>>>>>> pair is
isomorphic to the embedded_H / ⟨Ĥ⟩ pair you contradict yourself. >>>>>>>>>

So?

D(D) / Ĥ (Ĥ) still halt since H returns non-halting, thus that >>>>>>>> answer is wrong for the Halting Problem.

It only seems wrong because all of the textbooks reject simulating >>>>>>> halt deciders out-of-hand without review incorrectly assuming that >>>>>>> simulation cannot possibly be used as the basis of a halt decider: >>>>>>

No, it is wrong because the question asks about the actual
machine, and that halts, so the right answer is HALTING.

Yet any theory of computation computer scientist knows that a
simulation
of N steps by a UTM does provide that actual behavior of the actual
input to this UTM.

Nope, only if the machine reaches a final state in that Nth Step.

You just don't understand what a UTM is or what it does.

They also know that when the input to this UTM is defined to have a
pathological relationship to this UTM that this changes the
behavior of
this correctly simulated input.

Nope, a UTM simulation is only correct if it exactly matches the
FULL b4ehavior of the machine it is looking at. That is its DEFINITION. >>>>

Maybe I should begin my paper with this self-evident truth before
proceeding to the notion of a simulating halt decider.

Yes, do that, so anyone who actually understand the theory knows
from that start that you are a crackpot.

In any case the perfect isomorphism between H/D and embedded_H / ⟨Ĥ⟩ >>>>> already fully proves this point.

Why, since neither H or embedded_H are actually UTMs, and it is
establishied that both of them declare their input to be non-halting
when the machine they are given the description of Halt.

*Clearly you are clueless about what the term isomorphism means*
Both D and ⟨Ĥ⟩ have the exact same form in that both D and ⟨Ĥ⟩ >>> attempt to
do the opposite of whatever their corresponding halt decider determines. >>>
Both of them loop when their halt decider returns {halts} and both halt
when their halt decider returns {non-halting}. Both of them continue to
call the halt decider in recursive simulation until their halt decider
stops simulating them.

Right, so since the Halt Decider must have a defined behavior when
given them as an input, that defined behavior will always be wrong,
because no matter how you define your H, the machines will act the
other way. This is what proves that there can't be a decider that gets
all input right.

I did not say that precisely enough.

Both of the simulated inputs [WOULD] loop if their corresponding halt
decider [WOULD] return {halts} to them and [WOULD] halt loop if their corresponding halt decider [WOULD] return {non-halting} to them yet the actual case is that they remain stuck in recursive simulation until
their corresponding halt decider stops simulating them.

Nope, because the MUST give an answer in finite time based on a
determinsitic algorithm.

Thus, either they answer halting, and get a non-halting input, or they
answer non-halting, and get a Halting input.

Thus as you admitted for the H/D pair also applies to the
embedded_H / ⟨Ĥ⟩ pair. The simulated input cannot possibly terminate normally because it remains stuck in recursive simulation until the simulation is terminated *IN BOTH CASES*

Then you are saying you H will NEVER abort its simulation, and thus it
never answers and fails to be a decider.

Remember, the ultimate question is what the machine described by the
input does, and that machine calls H with EXACTLY the same parameters as
the independent call, and thus gets exactly the same answer, so H will
always be wrong.

If H doesn't return to D, it can NEVER return.

You try to clai otherwise, but when asked to show at what point between
the direct call to H, and the direct running of D calling H differ, you
can't point it out, because it doesn't happen. (Remember, we aren't
asking about D simulated by H, but D actually being run, calling H, just
like the indepenedant call to H and both of them then simuating the input.

Your arguement just shows that you don't understand how programs actual
work.

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

XPost: comp.theory, sci.logic

On 5/22/2023 10:12 PM, Richard Damon wrote:

On 5/22/23 10:49 PM, olcott wrote:

On 5/22/2023 9:27 PM, olcott wrote:

On 5/22/2023 9:02 PM, Richard Damon wrote:

On 5/22/23 9:33 PM, olcott wrote:

On 5/22/2023 6:22 PM, Richard Damon wrote:

On 5/22/23 10:22 AM, olcott wrote:

On 5/21/2023 2:02 PM, Richard Damon wrote:

On 5/21/23 2:50 PM, olcott wrote:

On 5/21/2023 1:39 PM, Richard Damon wrote:

On 5/21/23 2:12 PM, olcott wrote:

On 5/21/2023 11:54 AM, Richard Damon wrote:

On 5/21/23 10:16 AM, olcott wrote:

On 5/20/2023 6:52 PM, Richard Damon wrote:

On 5/20/23 5:29 PM, olcott wrote:

On 5/20/2023 4:24 PM, Richard Damon wrote:

On 5/20/23 5:10 PM, olcott wrote:

On 5/20/2023 3:48 PM, Richard Damon wrote:

On 5/20/23 4:33 PM, olcott wrote:

On 5/20/2023 2:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 5/20/23 3:29 PM, olcott wrote:

On 5/20/2023 1:54 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 5/20/23 2:46 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 1:15 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 1:09 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 11:10 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 11:24 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 10:19 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 10:54 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 8:49 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 12:00 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 10:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 11:00 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 9:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 8:56 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:

On 5/19/23 9:47 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Wrong Question! >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

In other words the question is over >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you head. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It took me many years to recognize >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this same dodge by Ben. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

No, it is the WRONG question once >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you try to apply the answer to the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem, which you do. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

So the software engineering really is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> over your head? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I see, so like Ben you have never >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually written any code. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

But you aren't talking about Software >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Engineering unless you are lying about >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this applying to the Halting Problem >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> described by Linz, since that is the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem of Computability Theory. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Of course, the likely explanation is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you are just ignorant of what you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are talking about, so you don't >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand the diference. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Ben kept masking his coding >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incompetence this way. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It never occurred to me that you have >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never written any code. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

I have possibly written more WORKING >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> code than you have. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

I don't believe you. Your inability to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer an straight forward >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> software engineering question seems to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove otherwise. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

What software engineering question? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

The answer to that question is NO, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Finally you admit an easily verified fact. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>

but that is because H doesn't, and can >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never do an accurarte simulation per the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a UTM. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

If the simulation by a UTM would be wrong >>>>>>>>>>>>>>>>>>>>>>>>>>>>> then you would have to be able >>>>>>>>>>>>>>>>>>>>>>>>>>>>> to point out the mistake in the simulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>> of D by H,

No, the simulation by a ACTUAL UTM will >>>>>>>>>>>>>>>>>>>>>>>>>>>> reach a final state.

I don't know why you say this when you >>>>>>>>>>>>>>>>>>>>>>>>>>> already know that ⟨Ĥ⟩ correctly >>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by embedded_H cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally.

Because embedded_H doesn't actually "Correctly >>>>>>>>>>>>>>>>>>>>>>>>>> Simulate" its input by the definintion aquired >>>>>>>>>>>>>>>>>>>>>>>>>> by your mentioning of a UTM. >>>>>>>>>>>>>>>>>>>>>>>>>>

You have already agreed that it does simulate >>>>>>>>>>>>>>>>>>>>>>>>> the first N steps
correctly. It is just as obvious that the >>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern of N steps of >>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ correctly simulated by embedded_H cannot >>>>>>>>>>>>>>>>>>>>>>>>> possibly terminate normally
even if the value of N is ∞. >>>>>>>>>>>>>>>>>>>>>>>>>

But N steps in not ALL steps as required by the >>>>>>>>>>>>>>>>>>>>>>>> actual definition of a UTM.

Actually N steps is the exact definition of a UTM >>>>>>>>>>>>>>>>>>>>>>> for those N steps.
Just like with the H/D example after N steps we >>>>>>>>>>>>>>>>>>>>>>> can see that neither
D correctly simulated by H nor ⟨Ĥ⟩ correctly >>>>>>>>>>>>>>>>>>>>>>> simulated by embedded_H
can possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>

Nope, UTMs have no concept of only doing a partial >>>>>>>>>>>>>>>>>>>>>> simulation.

When a simulating halt decider correctly simulates >>>>>>>>>>>>>>>>>>>>> N steps of its input
it derives the exact same N steps that a pure UTM >>>>>>>>>>>>>>>>>>>>> would derive because
it is itself a UTM with extra features. >>>>>>>>>>>>>>>>>>>>>

Just like a racing car is a street legal care with >>>>>>>>>>>>>>>>>>>> extra features that makes it no longer street legal. >>>>>>>>>>>>>>>>>>>>
The fact that H aborts its simulation part way means >>>>>>>>>>>>>>>>>>>> it is no longer a UTM

*Yet only at the point where it aborts its simulation* >>>>>>>>>>>>>>>>>>

Right, but that affect the behavior of ALL copies of >>>>>>>>>>>>>>>>>> it, since they all act the same.

Do you think you are immortal because you haven't died >>>>>>>>>>>>>>>>>> yet, and that everyone is immortal until the point in >>>>>>>>>>>>>>>>>> time they die?

Since it just proves it isn't a UTM, it can't assume >>>>>>>>>>>>>>>>>> that the copy it is simulating is, it needs to account >>>>>>>>>>>>>>>>>> for that behavior.

The fact that the DESIGN logic to do this goes into an >>>>>>>>>>>>>>>>>> infinite loop, doesn't mean that the program itself does. >>>>>>>>>>>>>>>>>>
Since H aborts its simulation and returns 0, its input >>>>>>>>>>>>>>>>>> will see its copy do exactly the same thing and thus >>>>>>>>>>>>>>>>>> will Halt, making the answer wrong.

Since H isn't a UTM, since if fails to meet the >>>>>>>>>>>>>>>>>> defintion, the fact that it can't reach a final state >>>>>>>>>>>>>>>>>> is irrelevent, as is any definiton of "Correct >>>>>>>>>>>>>>>>>> Simulation" that differs from what a UTM does. >>>>>>>>>>>>>>>>>>
UTM(D,D) Halts, therefore the CORRECT SIMULATION (by a >>>>>>>>>>>>>>>>>> UTM which is what is allowed to replace the actual >>>>>>>>>>>>>>>>>> behavior of the machine) Halts, and thus the CORRECT >>>>>>>>>>>>>>>>>> answer is Halting.

You are just showing that you have fallen for your own >>>>>>>>>>>>>>>>>> Strawman Deception that got you to use the wrong >>>>>>>>>>>>>>>>>> criteria.

At this point where it aborts its simulation we can >>>>>>>>>>>>>>>>>>> see that it must
do this to prevent its own infinite execution, thus >>>>>>>>>>>>>>>>>>> conclusively proving
that it correctly determined that its simulated input >>>>>>>>>>>>>>>>>>> cannot possibly
terminate normally.

How much longer are you going to play the fool and >>>>>>>>>>>>>>>>>>> deny this?

No, it does so because it has been programmed to do >>>>>>>>>>>>>>>>>> so, and thus ALL copies of it will do so.

It makes the error assuming that the copy it is >>>>>>>>>>>>>>>>>> simulating will do something different than it does. >>>>>>>>>>>>>>>>>

It makes no error. As you already admitted D correctly >>>>>>>>>>>>>>>>> simulated by H
cannot possibly terminate normally thus its isomorphism >>>>>>>>>>>>>>>>> of ⟨Ĥ⟩ correctly
simulated by embedded_H cannot possibly terminate >>>>>>>>>>>>>>>>> normally.

Are you going to keep playing the fool on this? >>>>>>>>>>>>>>>>>

Except that you are answering the wrong question. >>>>>>>>>>>>>>>>

In other words you want to keep playing the fool and >>>>>>>>>>>>>>> dodging the actual question that I am actually asking. >>>>>>>>>>>>>>

No, you are showing yourself to be the fool by not >>>>>>>>>>>>>> understand your own stupidity.

So you agreed that D correctly simulated H cannot >>>>>>>>>>>>>>> possibly terminate
normally and the exact same thing goes for ⟨Ĥ⟩ correctly >>>>>>>>>>>>>>> simulated by
embedded_H.

No, I am saying that H can not correctly simulate the >>>>>>>>>>>>>> input H and give an answer. If H DOES try to correctly >>>>>>>>>>>>>> simulate its input, then it can never giv an answer. >>>>>>>>>>>>>

Since you already acknowledged that D correctly simulated >>>>>>>>>>>>> by H can never
terminate normally and you did not need an infinite amount >>>>>>>>>>>>> of time to
determine this then the isomorphic ⟨Ĥ⟩ correctly simulated >>>>>>>>>>>>> by embedded_H
can also be determined to never terminate normally and this >>>>>>>>>>>>> determination can be made in a finite amount of time. >>>>>>>>>>>>>
In both cases this can be correctly determined after N >>>>>>>>>>>>> steps of
simulation thus no need for the infinite simulation that >>>>>>>>>>>>> you keep
insisting is necessary.

You keep on LYING about what I said. Any H that gives an >>>>>>>>>>>> answer can not "Correctly Simulate" this input per the >>>>>>>>>>>> definitions that allow simulation to replace the behavior of >>>>>>>>>>>> the actual machine.

Since you already acknowledged that D correctly simulated by >>>>>>>>>>> H cannot
possibly terminate normally (hence [key agreement]) and the >>>>>>>>>>> H/D pair is
isomorphic to the embedded_H / ⟨Ĥ⟩ pair you contradict yourself.

So?

D(D) / Ĥ (Ĥ) still halt since H returns non-halting, thus that >>>>>>>>>> answer is wrong for the Halting Problem.

It only seems wrong because all of the textbooks reject simulating >>>>>>>>> halt deciders out-of-hand without review incorrectly assuming that >>>>>>>>> simulation cannot possibly be used as the basis of a halt decider: >>>>>>>>

No, it is wrong because the question asks about the actual
machine, and that halts, so the right answer is HALTING.

Yet any theory of computation computer scientist knows that a
simulation
of N steps by a UTM does provide that actual behavior of the actual >>>>>>> input to this UTM.

Nope, only if the machine reaches a final state in that Nth Step.

You just don't understand what a UTM is or what it does.

They also know that when the input to this UTM is defined to have a >>>>>>> pathological relationship to this UTM that this changes the
behavior of
this correctly simulated input.

Nope, a UTM simulation is only correct if it exactly matches the
FULL b4ehavior of the machine it is looking at. That is its
DEFINITION.

Maybe I should begin my paper with this self-evident truth before >>>>>>> proceeding to the notion of a simulating halt decider.

Yes, do that, so anyone who actually understand the theory knows
from that start that you are a crackpot.

In any case the perfect isomorphism between H/D and embedded_H / ⟨Ĥ⟩
already fully proves this point.

Why, since neither H or embedded_H are actually UTMs, and it is
establishied that both of them declare their input to be
non-halting when the machine they are given the description of Halt. >>>>>>

*Clearly you are clueless about what the term isomorphism means*
Both D and ⟨Ĥ⟩ have the exact same form in that both D and ⟨Ĥ⟩ >>>>> attempt to
do the opposite of whatever their corresponding halt decider
determines.

Both of them loop when their halt decider returns {halts} and both
halt
when their halt decider returns {non-halting}. Both of them
continue to
call the halt decider in recursive simulation until their halt decider >>>>> stops simulating them.

Right, so since the Halt Decider must have a defined behavior when
given them as an input, that defined behavior will always be wrong,
because no matter how you define your H, the machines will act the
other way. This is what proves that there can't be a decider that
gets all input right.

I did not say that precisely enough.

Both of the simulated inputs [WOULD] loop if their corresponding halt
decider [WOULD] return {halts} to them and [WOULD] halt loop if their
corresponding halt decider [WOULD] return {non-halting} to them yet the
actual case is that they remain stuck in recursive simulation until
their corresponding halt decider stops simulating them.

Thus as you admitted for the H/D pair also applies to the
embedded_H / ⟨Ĥ⟩ pair. The simulated input cannot possibly terminate >>> normally because it remains stuck in recursive simulation until the
simulation is terminated *IN BOTH CASES*

You seem to be acting like the HBO Westworld character Bernard that was
a robot (AKA host) was almost perfectly a very smart human except that
his brain was hard-wired to not be able to "see" a specific door.

Then, once they're inside the dark house where Ford's robotic family
lives, Theresa asks what's behind one of the doors. "What door?" Bernard
asks, and that's when you know he's a host as well. The door is plain as
day, even in the dark, and he's been there before. And yet, he couldn't
see it.

https://www.forbes.com/sites/erikkain/2016/11/14/one-of-the-biggest-westworld-fan-theories-just-came-true/?sh=5bcd83a38a3e

So, where do Main -> H(D,D) and main -> D(D) -> H(D,D) differ in their execution path?

You claim they differ, so show it.

If you really do know software engineering then you already know on the
basis that you already agreed that D simulated by H cannot terminate
normally.

When you ask a question that you already know the answer to then you are
only playing head games.

That, or you are claiming that a "Correct Simulation" can differ from
the actual machine behavior, despite that going against the definition.

You already admitted that D simulated by H never terminates normally.
Thus you knew that H is correct to abort its simulation of D to prevent
its own infinite execution.

The reason that I did this concretely in C is the there is no wiggle
room of ambiguity to deny what is actually occurring.

I guess "Correct Reasoning" isn't something you use yourself, just that
you argue that others don't do.

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

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

On Monday, May 22, 2023 at 10:32:55 PM UTC-5, olcott wrote:

On 5/22/2023 10:12 PM, Richard Damon wrote:

On 5/22/23 10:49 PM, olcott wrote:

On 5/22/2023 9:27 PM, olcott wrote:

On 5/22/2023 9:02 PM, Richard Damon wrote:

On 5/22/23 9:33 PM, olcott wrote:

On 5/22/2023 6:22 PM, Richard Damon wrote:

On 5/22/23 10:22 AM, olcott wrote:

On 5/21/2023 2:02 PM, Richard Damon wrote:

On 5/21/23 2:50 PM, olcott wrote:

On 5/21/2023 1:39 PM, Richard Damon wrote:

On 5/21/23 2:12 PM, olcott wrote:

On 5/21/2023 11:54 AM, Richard Damon wrote:

On 5/21/23 10:16 AM, olcott wrote:

On 5/20/2023 6:52 PM, Richard Damon wrote:

On 5/20/23 5:29 PM, olcott wrote:

On 5/20/2023 4:24 PM, Richard Damon wrote:

On 5/20/23 5:10 PM, olcott wrote:

On 5/20/2023 3:48 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>> On 5/20/23 4:33 PM, olcott wrote:

On 5/20/2023 2:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 5/20/23 3:29 PM, olcott wrote:

On 5/20/2023 1:54 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 5/20/23 2:46 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 1:15 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 1:09 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 11:10 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 11:24 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 10:19 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 10:54 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 8:49 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 12:00 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 10:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 11:00 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 9:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 8:56 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Wrong Question! >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

In other words the question is over >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you head. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It took me many years to recognize >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this same dodge by Ben. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

No, it is the WRONG question once >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you try to apply the answer to the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem, which you do. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

So the software engineering really is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> over your head? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I see, so like Ben you have never >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually written any code. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

But you aren't talking about Software >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Engineering unless you are lying about >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this applying to the Halting Problem >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> described by Linz, since that is the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem of Computability Theory. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Of course, the likely explanation is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you are just ignorant of what you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are talking about, so you don't >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand the diference. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Ben kept masking his coding >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incompetence this way. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It never occurred to me that you have >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never written any code. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

I have possibly written more WORKING >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> code than you have. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

I don't believe you. Your inability to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer an straight forward >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> software engineering question seems to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove otherwise. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

What software engineering question? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

The answer to that question is NO, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Finally you admit an easily verified fact. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>

but that is because H doesn't, and can >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never do an accurarte simulation per the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a UTM. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

If the simulation by a UTM would be wrong >>>>>>>>>>>>>>>>>>>>>>>>>>>>> then you would have to be able >>>>>>>>>>>>>>>>>>>>>>>>>>>>> to point out the mistake in the simulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>> of D by H,

No, the simulation by a ACTUAL UTM will >>>>>>>>>>>>>>>>>>>>>>>>>>>> reach a final state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>

I don't know why you say this when you >>>>>>>>>>>>>>>>>>>>>>>>>>> already know that ⟨Ĥ⟩ correctly >>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by embedded_H cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally.

Because embedded_H doesn't actually "Correctly >>>>>>>>>>>>>>>>>>>>>>>>>> Simulate" its input by the definintion aquired >>>>>>>>>>>>>>>>>>>>>>>>>> by your mentioning of a UTM. >>>>>>>>>>>>>>>>>>>>>>>>>>

You have already agreed that it does simulate >>>>>>>>>>>>>>>>>>>>>>>>> the first N steps
correctly. It is just as obvious that the >>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern of N steps of >>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ correctly simulated by embedded_H cannot >>>>>>>>>>>>>>>>>>>>>>>>> possibly terminate normally >>>>>>>>>>>>>>>>>>>>>>>>> even if the value of N is ∞. >>>>>>>>>>>>>>>>>>>>>>>>>

But N steps in not ALL steps as required by the >>>>>>>>>>>>>>>>>>>>>>>> actual definition of a UTM. >>>>>>>>>>>>>>>>>>>>>>>>

Actually N steps is the exact definition of a UTM >>>>>>>>>>>>>>>>>>>>>>> for those N steps.
Just like with the H/D example after N steps we >>>>>>>>>>>>>>>>>>>>>>> can see that neither
D correctly simulated by H nor ⟨Ĥ⟩ correctly >>>>>>>>>>>>>>>>>>>>>>> simulated by embedded_H
can possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>

Nope, UTMs have no concept of only doing a partial >>>>>>>>>>>>>>>>>>>>>> simulation.

When a simulating halt decider correctly simulates >>>>>>>>>>>>>>>>>>>>> N steps of its input
it derives the exact same N steps that a pure UTM >>>>>>>>>>>>>>>>>>>>> would derive because
it is itself a UTM with extra features. >>>>>>>>>>>>>>>>>>>>>

Just like a racing car is a street legal care with >>>>>>>>>>>>>>>>>>>> extra features that makes it no longer street legal. >>>>>>>>>>>>>>>>>>>>
The fact that H aborts its simulation part way means >>>>>>>>>>>>>>>>>>>> it is no longer a UTM

*Yet only at the point where it aborts its simulation* >>>>>>>>>>>>>>>>>>

Right, but that affect the behavior of ALL copies of >>>>>>>>>>>>>>>>>> it, since they all act the same.

Do you think you are immortal because you haven't died >>>>>>>>>>>>>>>>>> yet, and that everyone is immortal until the point in >>>>>>>>>>>>>>>>>> time they die?

Since it just proves it isn't a UTM, it can't assume >>>>>>>>>>>>>>>>>> that the copy it is simulating is, it needs to account >>>>>>>>>>>>>>>>>> for that behavior.

The fact that the DESIGN logic to do this goes into an >>>>>>>>>>>>>>>>>> infinite loop, doesn't mean that the program itself does. >>>>>>>>>>>>>>>>>>
Since H aborts its simulation and returns 0, its input >>>>>>>>>>>>>>>>>> will see its copy do exactly the same thing and thus >>>>>>>>>>>>>>>>>> will Halt, making the answer wrong.

Since H isn't a UTM, since if fails to meet the >>>>>>>>>>>>>>>>>> defintion, the fact that it can't reach a final state >>>>>>>>>>>>>>>>>> is irrelevent, as is any definiton of "Correct >>>>>>>>>>>>>>>>>> Simulation" that differs from what a UTM does. >>>>>>>>>>>>>>>>>>
UTM(D,D) Halts, therefore the CORRECT SIMULATION (by a >>>>>>>>>>>>>>>>>> UTM which is what is allowed to replace the actual >>>>>>>>>>>>>>>>>> behavior of the machine) Halts, and thus the CORRECT >>>>>>>>>>>>>>>>>> answer is Halting.

You are just showing that you have fallen for your own >>>>>>>>>>>>>>>>>> Strawman Deception that got you to use the wrong >>>>>>>>>>>>>>>>>> criteria.

At this point where it aborts its simulation we can >>>>>>>>>>>>>>>>>>> see that it must
do this to prevent its own infinite execution, thus >>>>>>>>>>>>>>>>>>> conclusively proving
that it correctly determined that its simulated input >>>>>>>>>>>>>>>>>>> cannot possibly
terminate normally.

How much longer are you going to play the fool and >>>>>>>>>>>>>>>>>>> deny this?

No, it does so because it has been programmed to do >>>>>>>>>>>>>>>>>> so, and thus ALL copies of it will do so. >>>>>>>>>>>>>>>>>>
It makes the error assuming that the copy it is >>>>>>>>>>>>>>>>>> simulating will do something different than it does. >>>>>>>>>>>>>>>>>

It makes no error. As you already admitted D correctly >>>>>>>>>>>>>>>>> simulated by H
cannot possibly terminate normally thus its isomorphism >>>>>>>>>>>>>>>>> of ⟨Ĥ⟩ correctly
simulated by embedded_H cannot possibly terminate >>>>>>>>>>>>>>>>> normally.

Are you going to keep playing the fool on this? >>>>>>>>>>>>>>>>>

Except that you are answering the wrong question. >>>>>>>>>>>>>>>>

In other words you want to keep playing the fool and >>>>>>>>>>>>>>> dodging the actual question that I am actually asking. >>>>>>>>>>>>>>

No, you are showing yourself to be the fool by not >>>>>>>>>>>>>> understand your own stupidity.

So you agreed that D correctly simulated H cannot >>>>>>>>>>>>>>> possibly terminate
normally and the exact same thing goes for ⟨Ĥ⟩ correctly
simulated by
embedded_H.

No, I am saying that H can not correctly simulate the >>>>>>>>>>>>>> input H and give an answer. If H DOES try to correctly >>>>>>>>>>>>>> simulate its input, then it can never giv an answer. >>>>>>>>>>>>>

Since you already acknowledged that D correctly simulated >>>>>>>>>>>>> by H can never
terminate normally and you did not need an infinite amount >>>>>>>>>>>>> of time to
determine this then the isomorphic ⟨Ĥ⟩ correctly simulated
by embedded_H
can also be determined to never terminate normally and this >>>>>>>>>>>>> determination can be made in a finite amount of time. >>>>>>>>>>>>>
In both cases this can be correctly determined after N >>>>>>>>>>>>> steps of
simulation thus no need for the infinite simulation that >>>>>>>>>>>>> you keep
insisting is necessary.

You keep on LYING about what I said. Any H that gives an >>>>>>>>>>>> answer can not "Correctly Simulate" this input per the >>>>>>>>>>>> definitions that allow simulation to replace the behavior of >>>>>>>>>>>> the actual machine.

Since you already acknowledged that D correctly simulated by >>>>>>>>>>> H cannot
possibly terminate normally (hence [key agreement]) and the >>>>>>>>>>> H/D pair is
isomorphic to the embedded_H / ⟨Ĥ⟩ pair you contradict yourself.

So?

D(D) / Ĥ (Ĥ) still halt since H returns non-halting, thus that >>>>>>>>>> answer is wrong for the Halting Problem.

It only seems wrong because all of the textbooks reject simulating >>>>>>>>> halt deciders out-of-hand without review incorrectly assuming that >>>>>>>>> simulation cannot possibly be used as the basis of a halt decider: >>>>>>>>

No, it is wrong because the question asks about the actual
machine, and that halts, so the right answer is HALTING.

Yet any theory of computation computer scientist knows that a >>>>>>> simulation
of N steps by a UTM does provide that actual behavior of the actual >>>>>>> input to this UTM.

Nope, only if the machine reaches a final state in that Nth Step. >>>>>>
You just don't understand what a UTM is or what it does.

They also know that when the input to this UTM is defined to have a >>>>>>> pathological relationship to this UTM that this changes the
behavior of
this correctly simulated input.

Nope, a UTM simulation is only correct if it exactly matches the >>>>>> FULL b4ehavior of the machine it is looking at. That is its
DEFINITION.

Maybe I should begin my paper with this self-evident truth before >>>>>>> proceeding to the notion of a simulating halt decider.

Yes, do that, so anyone who actually understand the theory knows >>>>>> from that start that you are a crackpot.

In any case the perfect isomorphism between H/D and embedded_H / ⟨Ĥ⟩
already fully proves this point.

Why, since neither H or embedded_H are actually UTMs, and it is >>>>>> establishied that both of them declare their input to be
non-halting when the machine they are given the description of Halt. >>>>>>

*Clearly you are clueless about what the term isomorphism means*
Both D and ⟨Ĥ⟩ have the exact same form in that both D and ⟨Ĥ⟩
attempt to
do the opposite of whatever their corresponding halt decider
determines.

Both of them loop when their halt decider returns {halts} and both >>>>> halt
when their halt decider returns {non-halting}. Both of them
continue to
call the halt decider in recursive simulation until their halt decider >>>>> stops simulating them.

Right, so since the Halt Decider must have a defined behavior when
given them as an input, that defined behavior will always be wrong, >>>> because no matter how you define your H, the machines will act the
other way. This is what proves that there can't be a decider that
gets all input right.

I did not say that precisely enough.

Both of the simulated inputs [WOULD] loop if their corresponding halt >>> decider [WOULD] return {halts} to them and [WOULD] halt loop if their >>> corresponding halt decider [WOULD] return {non-halting} to them yet the >>> actual case is that they remain stuck in recursive simulation until
their corresponding halt decider stops simulating them.

Thus as you admitted for the H/D pair also applies to the
embedded_H / ⟨Ĥ⟩ pair. The simulated input cannot possibly terminate
normally because it remains stuck in recursive simulation until the
simulation is terminated *IN BOTH CASES*

You seem to be acting like the HBO Westworld character Bernard that was >> a robot (AKA host) was almost perfectly a very smart human except that
his brain was hard-wired to not be able to "see" a specific door.

Then, once they're inside the dark house where Ford's robotic family
lives, Theresa asks what's behind one of the doors. "What door?" Bernard >> asks, and that's when you know he's a host as well. The door is plain as >> day, even in the dark, and he's been there before. And yet, he couldn't >> see it.

https://www.forbes.com/sites/erikkain/2016/11/14/one-of-the-biggest-westworld-fan-theories-just-came-true/?sh=5bcd83a38a3e

So, where do Main -> H(D,D) and main -> D(D) -> H(D,D) differ in their execution path?

You claim they differ, so show it.

If you really do know software engineering then you already know on the basis that you already agreed that D simulated by H cannot terminate normally.

When you ask a question that you already know the answer to then you are only playing head games.

That, or you are claiming that a "Correct Simulation" can differ from
the actual machine behavior, despite that going against the definition.

You already admitted that D simulated by H never terminates normally.
Thus you knew that H is correct to abort its simulation of D to prevent
its own infinite execution.

The reason that I did this concretely in C is the there is no wiggle
room of ambiguity to deny what is actually occurring.

I guess "Correct Reasoning" isn't something you use yourself, just that you argue that others don't do.

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

I think what happened was that after I sent my email to you that some nefarious force within the bowels of the machine changed it around to that awful statement which got me in trouble and dissociated our relationship.

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

XPost: comp.theory, sci.logic

On 5/22/23 11:31 PM, olcott wrote:

On 5/22/2023 10:12 PM, Richard Damon wrote:

On 5/22/23 10:49 PM, olcott wrote:

On 5/22/2023 9:27 PM, olcott wrote:

On 5/22/2023 9:02 PM, Richard Damon wrote:

On 5/22/23 9:33 PM, olcott wrote:

On 5/22/2023 6:22 PM, Richard Damon wrote:

On 5/22/23 10:22 AM, olcott wrote:

On 5/21/2023 2:02 PM, Richard Damon wrote:

On 5/21/23 2:50 PM, olcott wrote:

On 5/21/2023 1:39 PM, Richard Damon wrote:

On 5/21/23 2:12 PM, olcott wrote:

On 5/21/2023 11:54 AM, Richard Damon wrote:

On 5/21/23 10:16 AM, olcott wrote:

On 5/20/2023 6:52 PM, Richard Damon wrote:

On 5/20/23 5:29 PM, olcott wrote:

On 5/20/2023 4:24 PM, Richard Damon wrote:

On 5/20/23 5:10 PM, olcott wrote:

On 5/20/2023 3:48 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 5/20/23 4:33 PM, olcott wrote:

On 5/20/2023 2:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 5/20/23 3:29 PM, olcott wrote:

On 5/20/2023 1:54 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 2:46 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 1:15 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 1:09 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 11:10 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 11:24 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 10:19 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 10:54 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 8:49 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 12:00 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 10:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 11:00 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 9:51 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:

On 5/19/23 10:10 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 8:56 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Wrong Question! >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

In other words the question is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> over you head. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It took me many years to recognize >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this same dodge by Ben. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

No, it is the WRONG question once >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you try to apply the answer to the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem, which you do. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

So the software engineering really >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is over your head? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I see, so like Ben you have never >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually written any code. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

But you aren't talking about Software >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Engineering unless you are lying >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about this applying to the Halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Problem described by Linz, since that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is the Halting Problem of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Computability Theory. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Of course, the likely explanation is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you are just ignorant of what >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are talking about, so you don't >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand the diference. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Ben kept masking his coding >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incompetence this way. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It never occurred to me that you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have never written any code. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

I have possibly written more WORKING >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> code than you have. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

I don't believe you. Your inability to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer an straight forward >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> software engineering question seems to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prove otherwise. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

What software engineering question? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

The answer to that question is NO, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Finally you admit an easily verified fact. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

but that is because H doesn't, and can >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never do an accurarte simulation per the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a UTM. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

If the simulation by a UTM would be wrong >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then you would have to be able >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to point out the mistake in the simulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of D by H,

No, the simulation by a ACTUAL UTM will >>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach a final state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>

I don't know why you say this when you >>>>>>>>>>>>>>>>>>>>>>>>>>>> already know that ⟨Ĥ⟩ correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by embedded_H cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally.

Because embedded_H doesn't actually >>>>>>>>>>>>>>>>>>>>>>>>>>> "Correctly Simulate" its input by the >>>>>>>>>>>>>>>>>>>>>>>>>>> definintion aquired by your mentioning of a UTM. >>>>>>>>>>>>>>>>>>>>>>>>>>>

You have already agreed that it does simulate >>>>>>>>>>>>>>>>>>>>>>>>>> the first N steps
correctly. It is just as obvious that the >>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern of N steps of >>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ correctly simulated by embedded_H cannot >>>>>>>>>>>>>>>>>>>>>>>>>> possibly terminate normally >>>>>>>>>>>>>>>>>>>>>>>>>> even if the value of N is ∞. >>>>>>>>>>>>>>>>>>>>>>>>>>

But N steps in not ALL steps as required by the >>>>>>>>>>>>>>>>>>>>>>>>> actual definition of a UTM.

Actually N steps is the exact definition of a >>>>>>>>>>>>>>>>>>>>>>>> UTM for those N steps.
Just like with the H/D example after N steps we >>>>>>>>>>>>>>>>>>>>>>>> can see that neither
D correctly simulated by H nor ⟨Ĥ⟩ correctly >>>>>>>>>>>>>>>>>>>>>>>> simulated by embedded_H
can possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>

Nope, UTMs have no concept of only doing a >>>>>>>>>>>>>>>>>>>>>>> partial simulation.

When a simulating halt decider correctly simulates >>>>>>>>>>>>>>>>>>>>>> N steps of its input
it derives the exact same N steps that a pure UTM >>>>>>>>>>>>>>>>>>>>>> would derive because
it is itself a UTM with extra features. >>>>>>>>>>>>>>>>>>>>>>

Just like a racing car is a street legal care with >>>>>>>>>>>>>>>>>>>>> extra features that makes it no longer street legal. >>>>>>>>>>>>>>>>>>>>>
The fact that H aborts its simulation part way >>>>>>>>>>>>>>>>>>>>> means it is no longer a UTM

*Yet only at the point where it aborts its simulation* >>>>>>>>>>>>>>>>>>>

Right, but that affect the behavior of ALL copies of >>>>>>>>>>>>>>>>>>> it, since they all act the same.

Do you think you are immortal because you haven't >>>>>>>>>>>>>>>>>>> died yet, and that everyone is immortal until the >>>>>>>>>>>>>>>>>>> point in time they die?

Since it just proves it isn't a UTM, it can't assume >>>>>>>>>>>>>>>>>>> that the copy it is simulating is, it needs to >>>>>>>>>>>>>>>>>>> account for that behavior.

The fact that the DESIGN logic to do this goes into >>>>>>>>>>>>>>>>>>> an infinite loop, doesn't mean that the program >>>>>>>>>>>>>>>>>>> itself does.

Since H aborts its simulation and returns 0, its >>>>>>>>>>>>>>>>>>> input will see its copy do exactly the same thing and >>>>>>>>>>>>>>>>>>> thus will Halt, making the answer wrong. >>>>>>>>>>>>>>>>>>>
Since H isn't a UTM, since if fails to meet the >>>>>>>>>>>>>>>>>>> defintion, the fact that it can't reach a final state >>>>>>>>>>>>>>>>>>> is irrelevent, as is any definiton of "Correct >>>>>>>>>>>>>>>>>>> Simulation" that differs from what a UTM does. >>>>>>>>>>>>>>>>>>>
UTM(D,D) Halts, therefore the CORRECT SIMULATION (by >>>>>>>>>>>>>>>>>>> a UTM which is what is allowed to replace the actual >>>>>>>>>>>>>>>>>>> behavior of the machine) Halts, and thus the CORRECT >>>>>>>>>>>>>>>>>>> answer is Halting.

You are just showing that you have fallen for your >>>>>>>>>>>>>>>>>>> own Strawman Deception that got you to use the wrong >>>>>>>>>>>>>>>>>>> criteria.

At this point where it aborts its simulation we can >>>>>>>>>>>>>>>>>>>> see that it must
do this to prevent its own infinite execution, thus >>>>>>>>>>>>>>>>>>>> conclusively proving
that it correctly determined that its simulated >>>>>>>>>>>>>>>>>>>> input cannot possibly
terminate normally.

How much longer are you going to play the fool and >>>>>>>>>>>>>>>>>>>> deny this?

No, it does so because it has been programmed to do >>>>>>>>>>>>>>>>>>> so, and thus ALL copies of it will do so. >>>>>>>>>>>>>>>>>>>
It makes the error assuming that the copy it is >>>>>>>>>>>>>>>>>>> simulating will do something different than it does. >>>>>>>>>>>>>>>>>>

It makes no error. As you already admitted D correctly >>>>>>>>>>>>>>>>>> simulated by H
cannot possibly terminate normally thus its >>>>>>>>>>>>>>>>>> isomorphism of ⟨Ĥ⟩ correctly
simulated by embedded_H cannot possibly terminate >>>>>>>>>>>>>>>>>> normally.

Are you going to keep playing the fool on this? >>>>>>>>>>>>>>>>>>

Except that you are answering the wrong question. >>>>>>>>>>>>>>>>>

In other words you want to keep playing the fool and >>>>>>>>>>>>>>>> dodging the actual question that I am actually asking. >>>>>>>>>>>>>>>

No, you are showing yourself to be the fool by not >>>>>>>>>>>>>>> understand your own stupidity.

So you agreed that D correctly simulated H cannot >>>>>>>>>>>>>>>> possibly terminate
normally and the exact same thing goes for ⟨Ĥ⟩ correctly >>>>>>>>>>>>>>>> simulated by
embedded_H.

No, I am saying that H can not correctly simulate the >>>>>>>>>>>>>>> input H and give an answer. If H DOES try to correctly >>>>>>>>>>>>>>> simulate its input, then it can never giv an answer. >>>>>>>>>>>>>>

Since you already acknowledged that D correctly simulated >>>>>>>>>>>>>> by H can never
terminate normally and you did not need an infinite amount >>>>>>>>>>>>>> of time to
determine this then the isomorphic ⟨Ĥ⟩ correctly simulated >>>>>>>>>>>>>> by embedded_H
can also be determined to never terminate normally and this >>>>>>>>>>>>>> determination can be made in a finite amount of time. >>>>>>>>>>>>>>
In both cases this can be correctly determined after N >>>>>>>>>>>>>> steps of
simulation thus no need for the infinite simulation that >>>>>>>>>>>>>> you keep
insisting is necessary.

You keep on LYING about what I said. Any H that gives an >>>>>>>>>>>>> answer can not "Correctly Simulate" this input per the >>>>>>>>>>>>> definitions that allow simulation to replace the behavior >>>>>>>>>>>>> of the actual machine.

Since you already acknowledged that D correctly simulated by >>>>>>>>>>>> H cannot
possibly terminate normally (hence [key agreement]) and the >>>>>>>>>>>> H/D pair is
isomorphic to the embedded_H / ⟨Ĥ⟩ pair you contradict >>>>>>>>>>>> yourself.

So?

D(D) / Ĥ (Ĥ) still halt since H returns non-halting, thus >>>>>>>>>>> that answer is wrong for the Halting Problem.

It only seems wrong because all of the textbooks reject
simulating
halt deciders out-of-hand without review incorrectly assuming >>>>>>>>>> that
simulation cannot possibly be used as the basis of a halt
decider:

No, it is wrong because the question asks about the actual
machine, and that halts, so the right answer is HALTING.

Yet any theory of computation computer scientist knows that a
simulation
of N steps by a UTM does provide that actual behavior of the actual >>>>>>>> input to this UTM.

Nope, only if the machine reaches a final state in that Nth Step. >>>>>>>
You just don't understand what a UTM is or what it does.

They also know that when the input to this UTM is defined to have a >>>>>>>> pathological relationship to this UTM that this changes the
behavior of
this correctly simulated input.

Nope, a UTM simulation is only correct if it exactly matches the >>>>>>> FULL b4ehavior of the machine it is looking at. That is its
DEFINITION.

Maybe I should begin my paper with this self-evident truth before >>>>>>>> proceeding to the notion of a simulating halt decider.

Yes, do that, so anyone who actually understand the theory knows >>>>>>> from that start that you are a crackpot.

In any case the perfect isomorphism between H/D and embedded_H / >>>>>>>> ⟨Ĥ⟩
already fully proves this point.

Why, since neither H or embedded_H are actually UTMs, and it is
establishied that both of them declare their input to be
non-halting when the machine they are given the description of Halt. >>>>>>>

*Clearly you are clueless about what the term isomorphism means*
Both D and ⟨Ĥ⟩ have the exact same form in that both D and ⟨Ĥ⟩ >>>>>> attempt to
do the opposite of whatever their corresponding halt decider
determines.

Both of them loop when their halt decider returns {halts} and both >>>>>> halt
when their halt decider returns {non-halting}. Both of them
continue to
call the halt decider in recursive simulation until their halt
decider
stops simulating them.

Right, so since the Halt Decider must have a defined behavior when
given them as an input, that defined behavior will always be wrong,
because no matter how you define your H, the machines will act the
other way. This is what proves that there can't be a decider that
gets all input right.

I did not say that precisely enough.

Both of the simulated inputs [WOULD] loop if their corresponding halt
decider [WOULD] return {halts} to them and [WOULD] halt loop if their
corresponding halt decider [WOULD] return {non-halting} to them yet the >>>> actual case is that they remain stuck in recursive simulation until
their corresponding halt decider stops simulating them.

Thus as you admitted for the H/D pair also applies to the
embedded_H / ⟨Ĥ⟩ pair. The simulated input cannot possibly terminate >>>> normally because it remains stuck in recursive simulation until the
simulation is terminated *IN BOTH CASES*

You seem to be acting like the HBO Westworld character Bernard that was
a robot (AKA host) was almost perfectly a very smart human except that
his brain was hard-wired to not be able to "see" a specific door.

Then, once they're inside the dark house where Ford's robotic family
lives, Theresa asks what's behind one of the doors. "What door?" Bernard >>> asks, and that's when you know he's a host as well. The door is plain as >>> day, even in the dark, and he's been there before. And yet, he couldn't
see it.

https://www.forbes.com/sites/erikkain/2016/11/14/one-of-the-biggest-westworld-fan-theories-just-came-true/?sh=5bcd83a38a3e

So, where do Main -> H(D,D) and main -> D(D) -> H(D,D) differ in their
execution path?

You claim they differ, so show it.

If you really do know software engineering then you already know on the
basis that you already agreed that D simulated by H cannot terminate normally.

Yes, but the question isn't what does the (partial) simulation by H
show, but what does the machine repesented by the input do.

Since H doesn't simulate all of the behavior of D, its simulation
doesn't directly prove that answer.

When you ask a question that you already know the answer to then you are
only playing head games.

Excdpt what the simulation by H does isn't the question that H is
supposed to be answering.

That, or you are claiming that a "Correct Simulation" can differ from
the actual machine behavior, despite that going against the definition.

You already admitted that D simulated by H never terminates normally.
Thus you knew that H is correct to abort its simulation of D to prevent
its own infinite execution.

H is allowed to abort its simulation for any reason its programmer
wants. It still needs to give the right answer to be correct, and that
answer needs to describe the behavior of directly running the machine
given an input.

Since H(D,D) has been said to return 0, we can by simple inspection, and
verify by actually running it, see that D(D) will Halt, which means that
H's answer is just wrong.

It might be a correct POOP decider, but only you seem interested in your
POOP.

The reason that I did this concretely in C is the there is no wiggle
room of ambiguity to deny what is actually occurring.

Nither is there in Turing Machines.

I guess "Correct Reasoning" isn't something you use yourself, just
that you argue that others don't do.

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

XPost: comp.theory, sci.logic

On 5/23/2023 6:44 AM, Richard Damon wrote:

On 5/22/23 11:31 PM, olcott wrote:

On 5/22/2023 10:12 PM, Richard Damon wrote:

On 5/22/23 10:49 PM, olcott wrote:

On 5/22/2023 9:27 PM, olcott wrote:

On 5/22/2023 9:02 PM, Richard Damon wrote:

On 5/22/23 9:33 PM, olcott wrote:

On 5/22/2023 6:22 PM, Richard Damon wrote:

On 5/22/23 10:22 AM, olcott wrote:

On 5/21/2023 2:02 PM, Richard Damon wrote:

On 5/21/23 2:50 PM, olcott wrote:

On 5/21/2023 1:39 PM, Richard Damon wrote:

On 5/21/23 2:12 PM, olcott wrote:

On 5/21/2023 11:54 AM, Richard Damon wrote:

On 5/21/23 10:16 AM, olcott wrote:

On 5/20/2023 6:52 PM, Richard Damon wrote:

On 5/20/23 5:29 PM, olcott wrote:

On 5/20/2023 4:24 PM, Richard Damon wrote:

On 5/20/23 5:10 PM, olcott wrote:

On 5/20/2023 3:48 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 5/20/23 4:33 PM, olcott wrote:

On 5/20/2023 2:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 5/20/23 3:29 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 1:54 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 2:46 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 1:15 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 1:09 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 11:10 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 11:24 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 10:19 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 10:54 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 8:49 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 12:00 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 10:27 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:

On 5/19/23 11:00 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 9:51 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:

On 5/19/23 10:10 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 8:56 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Wrong Question! >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

In other words the question is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> over you head. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It took me many years to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recognize this same dodge by Ben. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

No, it is the WRONG question once >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you try to apply the answer to the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem, which you do. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

So the software engineering really >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is over your head? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I see, so like Ben you have never >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually written any code. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

But you aren't talking about >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Software Engineering unless you are >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> lying about this applying to the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem described by Linz, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> since that is the Halting Problem of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Computability Theory. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Of course, the likely explanation is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that you are just ignorant of what >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you are talking about, so you don't >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand the diference. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Ben kept masking his coding >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incompetence this way. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It never occurred to me that you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have never written any code. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

I have possibly written more WORKING >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> code than you have. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

I don't believe you. Your inability >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to answer an straight forward >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> software engineering question seems >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to prove otherwise. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

What software engineering question? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

The answer to that question is NO, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Finally you admit an easily verified fact. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

but that is because H doesn't, and can >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never do an accurarte simulation per the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of a UTM. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

If the simulation by a UTM would be wrong >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then you would have to be able >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to point out the mistake in the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of D by H, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

No, the simulation by a ACTUAL UTM will >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach a final state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

I don't know why you say this when you >>>>>>>>>>>>>>>>>>>>>>>>>>>>> already know that ⟨Ĥ⟩ correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by embedded_H cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally.

Because embedded_H doesn't actually >>>>>>>>>>>>>>>>>>>>>>>>>>>> "Correctly Simulate" its input by the >>>>>>>>>>>>>>>>>>>>>>>>>>>> definintion aquired by your mentioning of a >>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM.

You have already agreed that it does simulate >>>>>>>>>>>>>>>>>>>>>>>>>>> the first N steps
correctly. It is just as obvious that the >>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern of N steps of >>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ correctly simulated by embedded_H cannot >>>>>>>>>>>>>>>>>>>>>>>>>>> possibly terminate normally >>>>>>>>>>>>>>>>>>>>>>>>>>> even if the value of N is ∞. >>>>>>>>>>>>>>>>>>>>>>>>>>>

But N steps in not ALL steps as required by >>>>>>>>>>>>>>>>>>>>>>>>>> the actual definition of a UTM. >>>>>>>>>>>>>>>>>>>>>>>>>>

Actually N steps is the exact definition of a >>>>>>>>>>>>>>>>>>>>>>>>> UTM for those N steps.
Just like with the H/D example after N steps we >>>>>>>>>>>>>>>>>>>>>>>>> can see that neither
D correctly simulated by H nor ⟨Ĥ⟩ correctly >>>>>>>>>>>>>>>>>>>>>>>>> simulated by embedded_H
can possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>

Nope, UTMs have no concept of only doing a >>>>>>>>>>>>>>>>>>>>>>>> partial simulation.

When a simulating halt decider correctly >>>>>>>>>>>>>>>>>>>>>>> simulates N steps of its input
it derives the exact same N steps that a pure UTM >>>>>>>>>>>>>>>>>>>>>>> would derive because
it is itself a UTM with extra features. >>>>>>>>>>>>>>>>>>>>>>>

Just like a racing car is a street legal care with >>>>>>>>>>>>>>>>>>>>>> extra features that makes it no longer street legal. >>>>>>>>>>>>>>>>>>>>>>
The fact that H aborts its simulation part way >>>>>>>>>>>>>>>>>>>>>> means it is no longer a UTM

*Yet only at the point where it aborts its simulation* >>>>>>>>>>>>>>>>>>>>

Right, but that affect the behavior of ALL copies of >>>>>>>>>>>>>>>>>>>> it, since they all act the same.

Do you think you are immortal because you haven't >>>>>>>>>>>>>>>>>>>> died yet, and that everyone is immortal until the >>>>>>>>>>>>>>>>>>>> point in time they die?

Since it just proves it isn't a UTM, it can't assume >>>>>>>>>>>>>>>>>>>> that the copy it is simulating is, it needs to >>>>>>>>>>>>>>>>>>>> account for that behavior.

The fact that the DESIGN logic to do this goes into >>>>>>>>>>>>>>>>>>>> an infinite loop, doesn't mean that the program >>>>>>>>>>>>>>>>>>>> itself does.

Since H aborts its simulation and returns 0, its >>>>>>>>>>>>>>>>>>>> input will see its copy do exactly the same thing >>>>>>>>>>>>>>>>>>>> and thus will Halt, making the answer wrong. >>>>>>>>>>>>>>>>>>>>
Since H isn't a UTM, since if fails to meet the >>>>>>>>>>>>>>>>>>>> defintion, the fact that it can't reach a final >>>>>>>>>>>>>>>>>>>> state is irrelevent, as is any definiton of "Correct >>>>>>>>>>>>>>>>>>>> Simulation" that differs from what a UTM does. >>>>>>>>>>>>>>>>>>>>
UTM(D,D) Halts, therefore the CORRECT SIMULATION (by >>>>>>>>>>>>>>>>>>>> a UTM which is what is allowed to replace the actual >>>>>>>>>>>>>>>>>>>> behavior of the machine) Halts, and thus the CORRECT >>>>>>>>>>>>>>>>>>>> answer is Halting.

You are just showing that you have fallen for your >>>>>>>>>>>>>>>>>>>> own Strawman Deception that got you to use the wrong >>>>>>>>>>>>>>>>>>>> criteria.

At this point where it aborts its simulation we can >>>>>>>>>>>>>>>>>>>>> see that it must
do this to prevent its own infinite execution, thus >>>>>>>>>>>>>>>>>>>>> conclusively proving
that it correctly determined that its simulated >>>>>>>>>>>>>>>>>>>>> input cannot possibly
terminate normally.

How much longer are you going to play the fool and >>>>>>>>>>>>>>>>>>>>> deny this?

No, it does so because it has been programmed to do >>>>>>>>>>>>>>>>>>>> so, and thus ALL copies of it will do so. >>>>>>>>>>>>>>>>>>>>
It makes the error assuming that the copy it is >>>>>>>>>>>>>>>>>>>> simulating will do something different than it does. >>>>>>>>>>>>>>>>>>>

It makes no error. As you already admitted D >>>>>>>>>>>>>>>>>>> correctly simulated by H
cannot possibly terminate normally thus its >>>>>>>>>>>>>>>>>>> isomorphism of ⟨Ĥ⟩ correctly
simulated by embedded_H cannot possibly terminate >>>>>>>>>>>>>>>>>>> normally.

Are you going to keep playing the fool on this? >>>>>>>>>>>>>>>>>>>

Except that you are answering the wrong question. >>>>>>>>>>>>>>>>>>

In other words you want to keep playing the fool and >>>>>>>>>>>>>>>>> dodging the actual question that I am actually asking. >>>>>>>>>>>>>>>>

No, you are showing yourself to be the fool by not >>>>>>>>>>>>>>>> understand your own stupidity.

So you agreed that D correctly simulated H cannot >>>>>>>>>>>>>>>>> possibly terminate
normally and the exact same thing goes for ⟨Ĥ⟩ >>>>>>>>>>>>>>>>> correctly simulated by
embedded_H.

No, I am saying that H can not correctly simulate the >>>>>>>>>>>>>>>> input H and give an answer. If H DOES try to correctly >>>>>>>>>>>>>>>> simulate its input, then it can never giv an answer. >>>>>>>>>>>>>>>

Since you already acknowledged that D correctly simulated >>>>>>>>>>>>>>> by H can never
terminate normally and you did not need an infinite >>>>>>>>>>>>>>> amount of time to
determine this then the isomorphic ⟨Ĥ⟩ correctly >>>>>>>>>>>>>>> simulated by embedded_H
can also be determined to never terminate normally and this >>>>>>>>>>>>>>> determination can be made in a finite amount of time. >>>>>>>>>>>>>>>
In both cases this can be correctly determined after N >>>>>>>>>>>>>>> steps of
simulation thus no need for the infinite simulation that >>>>>>>>>>>>>>> you keep
insisting is necessary.

You keep on LYING about what I said. Any H that gives an >>>>>>>>>>>>>> answer can not "Correctly Simulate" this input per the >>>>>>>>>>>>>> definitions that allow simulation to replace the behavior >>>>>>>>>>>>>> of the actual machine.

Since you already acknowledged that D correctly simulated >>>>>>>>>>>>> by H cannot
possibly terminate normally (hence [key agreement]) and the >>>>>>>>>>>>> H/D pair is
isomorphic to the embedded_H / ⟨Ĥ⟩ pair you contradict >>>>>>>>>>>>> yourself.

So?

D(D) / Ĥ (Ĥ) still halt since H returns non-halting, thus >>>>>>>>>>>> that answer is wrong for the Halting Problem.

It only seems wrong because all of the textbooks reject
simulating
halt deciders out-of-hand without review incorrectly assuming >>>>>>>>>>> that
simulation cannot possibly be used as the basis of a halt >>>>>>>>>>> decider:

No, it is wrong because the question asks about the actual >>>>>>>>>> machine, and that halts, so the right answer is HALTING.

Yet any theory of computation computer scientist knows that a >>>>>>>>> simulation
of N steps by a UTM does provide that actual behavior of the >>>>>>>>> actual
input to this UTM.

Nope, only if the machine reaches a final state in that Nth Step. >>>>>>>>
You just don't understand what a UTM is or what it does.

They also know that when the input to this UTM is defined to >>>>>>>>> have a
pathological relationship to this UTM that this changes the
behavior of
this correctly simulated input.

Nope, a UTM simulation is only correct if it exactly matches the >>>>>>>> FULL b4ehavior of the machine it is looking at. That is its
DEFINITION.

Maybe I should begin my paper with this self-evident truth before >>>>>>>>> proceeding to the notion of a simulating halt decider.

Yes, do that, so anyone who actually understand the theory knows >>>>>>>> from that start that you are a crackpot.

In any case the perfect isomorphism between H/D and embedded_H >>>>>>>>> / ⟨Ĥ⟩
already fully proves this point.

Why, since neither H or embedded_H are actually UTMs, and it is >>>>>>>> establishied that both of them declare their input to be
non-halting when the machine they are given the description of >>>>>>>> Halt.

*Clearly you are clueless about what the term isomorphism means* >>>>>>> Both D and ⟨Ĥ⟩ have the exact same form in that both D and ⟨Ĥ⟩
attempt to
do the opposite of whatever their corresponding halt decider
determines.

Both of them loop when their halt decider returns {halts} and
both halt
when their halt decider returns {non-halting}. Both of them
continue to
call the halt decider in recursive simulation until their halt
decider
stops simulating them.

Right, so since the Halt Decider must have a defined behavior when >>>>>> given them as an input, that defined behavior will always be
wrong, because no matter how you define your H, the machines will
act the other way. This is what proves that there can't be a
decider that gets all input right.

I did not say that precisely enough.

Both of the simulated inputs [WOULD] loop if their corresponding halt >>>>> decider [WOULD] return {halts} to them and [WOULD] halt loop if their >>>>> corresponding halt decider [WOULD] return {non-halting} to them yet
the
actual case is that they remain stuck in recursive simulation until
their corresponding halt decider stops simulating them.

Thus as you admitted for the H/D pair also applies to the
embedded_H / ⟨Ĥ⟩ pair. The simulated input cannot possibly terminate >>>>> normally because it remains stuck in recursive simulation until the
simulation is terminated *IN BOTH CASES*

You seem to be acting like the HBO Westworld character Bernard that was >>>> a robot (AKA host) was almost perfectly a very smart human except that >>>> his brain was hard-wired to not be able to "see" a specific door.

Then, once they're inside the dark house where Ford's robotic family
lives, Theresa asks what's behind one of the doors. "What door?"
Bernard
asks, and that's when you know he's a host as well. The door is
plain as
day, even in the dark, and he's been there before. And yet, he couldn't >>>> see it.

https://www.forbes.com/sites/erikkain/2016/11/14/one-of-the-biggest-westworld-fan-theories-just-came-true/?sh=5bcd83a38a3e

So, where do Main -> H(D,D) and main -> D(D) -> H(D,D) differ in
their execution path?

You claim they differ, so show it.

If you really do know software engineering then you already know on the
basis that you already agreed that D simulated by H cannot terminate
normally.

Yes, but the question isn't what does the (partial) simulation by H
show, but what does the machine repesented by the input do.

Since H doesn't simulate all of the behavior of D, its simulation
doesn't directly prove that answer.

When you ask a question that you already know the answer to then you are
only playing head games.

Excdpt what the simulation by H does isn't the question that H is
supposed to be answering.

That, or you are claiming that a "Correct Simulation" can differ from
the actual machine behavior, despite that going against the definition.

You already admitted that D simulated by H never terminates normally.
Thus you knew that H is correct to abort its simulation of D to prevent
its own infinite execution.

H is allowed to abort its simulation for any reason its programmer
wants. It still needs to give the right answer to be correct, and that
answer needs to describe the behavior of directly running the machine
given an input.

Since H(D,D) has been said to return 0, we can by simple inspection, and verify by actually running it, see that D(D) will Halt, which means that
H's answer is just wrong.

It might be a correct POOP decider, but only you seem interested in your POOP.

The reason that I did this concretely in C is the there is no wiggle
room of ambiguity to deny what is actually occurring.

My way results in a halt decider that recognizes the actual behavior of
the actual input so that it doesn't get stuck in recursive simulation.

You way simply denies the reality actual behavior of the actual input
and gets stuck in infinite recursion.

When a simulating halt decider
(a) H correctly simulates N steps of its input D until
(b) H correctly determines that its simulated D would never stop running
unless aborted then
(c) H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.

Nither is there in Turing Machines.

I guess "Correct Reasoning" isn't something you use yourself, just
that you argue that others don't do.

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

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

XPost: comp.theory, sci.logic

On 5/23/23 9:50 AM, olcott wrote:

On 5/23/2023 6:44 AM, Richard Damon wrote:

On 5/22/23 11:31 PM, olcott wrote:

On 5/22/2023 10:12 PM, Richard Damon wrote:

On 5/22/23 10:49 PM, olcott wrote:

On 5/22/2023 9:27 PM, olcott wrote:

On 5/22/2023 9:02 PM, Richard Damon wrote:

On 5/22/23 9:33 PM, olcott wrote:

On 5/22/2023 6:22 PM, Richard Damon wrote:

On 5/22/23 10:22 AM, olcott wrote:

On 5/21/2023 2:02 PM, Richard Damon wrote:

On 5/21/23 2:50 PM, olcott wrote:

On 5/21/2023 1:39 PM, Richard Damon wrote:

On 5/21/23 2:12 PM, olcott wrote:

On 5/21/2023 11:54 AM, Richard Damon wrote:

On 5/21/23 10:16 AM, olcott wrote:

On 5/20/2023 6:52 PM, Richard Damon wrote:

On 5/20/23 5:29 PM, olcott wrote:

On 5/20/2023 4:24 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 5/20/23 5:10 PM, olcott wrote:

On 5/20/2023 3:48 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 5/20/23 4:33 PM, olcott wrote:

On 5/20/2023 2:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 3:29 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 1:54 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 2:46 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 1:15 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 1:09 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 11:10 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 11:24 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 10:19 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 10:54 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 8:49 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 12:00 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 10:27 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:

On 5/19/23 11:00 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 9:51 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 8:56 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Wrong Question! >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> In other words the question is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> over you head. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It took me many years to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recognize this same dodge by Ben. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

No, it is the WRONG question once >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you try to apply the answer to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the Halting Problem, which you do. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

So the software engineering really >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is over your head? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I see, so like Ben you have never >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually written any code. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

But you aren't talking about >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Software Engineering unless you are >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> lying about this applying to the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Halting Problem described by Linz, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> since that is the Halting Problem >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of Computability Theory. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Of course, the likely explanation >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is that you are just ignorant of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what you are talking about, so you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> don't understand the diference. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Ben kept masking his coding >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incompetence this way. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It never occurred to me that you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have never written any code. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

I have possibly written more >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WORKING code than you have. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

I don't believe you. Your inability >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to answer an straight forward >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> software engineering question seems >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to prove otherwise. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

What software engineering question? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

The answer to that question is NO, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Finally you admit an easily verified fact. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

but that is because H doesn't, and can >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never do an accurarte simulation per >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the definition of a UTM. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

If the simulation by a UTM would be >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong then you would have to be able >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to point out the mistake in the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of D by H, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

No, the simulation by a ACTUAL UTM will >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach a final state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

I don't know why you say this when you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> already know that ⟨Ĥ⟩ correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by embedded_H cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Because embedded_H doesn't actually >>>>>>>>>>>>>>>>>>>>>>>>>>>>> "Correctly Simulate" its input by the >>>>>>>>>>>>>>>>>>>>>>>>>>>>> definintion aquired by your mentioning of a >>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM.

You have already agreed that it does >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulate the first N steps >>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly. It is just as obvious that the >>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern of N steps of >>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ correctly simulated by embedded_H cannot >>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly terminate normally >>>>>>>>>>>>>>>>>>>>>>>>>>>> even if the value of N is ∞. >>>>>>>>>>>>>>>>>>>>>>>>>>>>

But N steps in not ALL steps as required by >>>>>>>>>>>>>>>>>>>>>>>>>>> the actual definition of a UTM. >>>>>>>>>>>>>>>>>>>>>>>>>>>

Actually N steps is the exact definition of a >>>>>>>>>>>>>>>>>>>>>>>>>> UTM for those N steps.
Just like with the H/D example after N steps >>>>>>>>>>>>>>>>>>>>>>>>>> we can see that neither
D correctly simulated by H nor ⟨Ĥ⟩ correctly >>>>>>>>>>>>>>>>>>>>>>>>>> simulated by embedded_H
can possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>

Nope, UTMs have no concept of only doing a >>>>>>>>>>>>>>>>>>>>>>>>> partial simulation.

When a simulating halt decider correctly >>>>>>>>>>>>>>>>>>>>>>>> simulates N steps of its input >>>>>>>>>>>>>>>>>>>>>>>> it derives the exact same N steps that a pure >>>>>>>>>>>>>>>>>>>>>>>> UTM would derive because
it is itself a UTM with extra features. >>>>>>>>>>>>>>>>>>>>>>>>

Just like a racing car is a street legal care >>>>>>>>>>>>>>>>>>>>>>> with extra features that makes it no longer >>>>>>>>>>>>>>>>>>>>>>> street legal.

The fact that H aborts its simulation part way >>>>>>>>>>>>>>>>>>>>>>> means it is no longer a UTM

*Yet only at the point where it aborts its >>>>>>>>>>>>>>>>>>>>>> simulation*

Right, but that affect the behavior of ALL copies >>>>>>>>>>>>>>>>>>>>> of it, since they all act the same.

Do you think you are immortal because you haven't >>>>>>>>>>>>>>>>>>>>> died yet, and that everyone is immortal until the >>>>>>>>>>>>>>>>>>>>> point in time they die?

Since it just proves it isn't a UTM, it can't >>>>>>>>>>>>>>>>>>>>> assume that the copy it is simulating is, it needs >>>>>>>>>>>>>>>>>>>>> to account for that behavior.

The fact that the DESIGN logic to do this goes into >>>>>>>>>>>>>>>>>>>>> an infinite loop, doesn't mean that the program >>>>>>>>>>>>>>>>>>>>> itself does.

Since H aborts its simulation and returns 0, its >>>>>>>>>>>>>>>>>>>>> input will see its copy do exactly the same thing >>>>>>>>>>>>>>>>>>>>> and thus will Halt, making the answer wrong. >>>>>>>>>>>>>>>>>>>>>
Since H isn't a UTM, since if fails to meet the >>>>>>>>>>>>>>>>>>>>> defintion, the fact that it can't reach a final >>>>>>>>>>>>>>>>>>>>> state is irrelevent, as is any definiton of >>>>>>>>>>>>>>>>>>>>> "Correct Simulation" that differs from what a UTM >>>>>>>>>>>>>>>>>>>>> does.

UTM(D,D) Halts, therefore the CORRECT SIMULATION >>>>>>>>>>>>>>>>>>>>> (by a UTM which is what is allowed to replace the >>>>>>>>>>>>>>>>>>>>> actual behavior of the machine) Halts, and thus the >>>>>>>>>>>>>>>>>>>>> CORRECT answer is Halting.

You are just showing that you have fallen for your >>>>>>>>>>>>>>>>>>>>> own Strawman Deception that got you to use the >>>>>>>>>>>>>>>>>>>>> wrong criteria.

At this point where it aborts its simulation we >>>>>>>>>>>>>>>>>>>>>> can see that it must
do this to prevent its own infinite execution, >>>>>>>>>>>>>>>>>>>>>> thus conclusively proving
that it correctly determined that its simulated >>>>>>>>>>>>>>>>>>>>>> input cannot possibly
terminate normally.

How much longer are you going to play the fool and >>>>>>>>>>>>>>>>>>>>>> deny this?

No, it does so because it has been programmed to do >>>>>>>>>>>>>>>>>>>>> so, and thus ALL copies of it will do so. >>>>>>>>>>>>>>>>>>>>>
It makes the error assuming that the copy it is >>>>>>>>>>>>>>>>>>>>> simulating will do something different than it does. >>>>>>>>>>>>>>>>>>>>

It makes no error. As you already admitted D >>>>>>>>>>>>>>>>>>>> correctly simulated by H
cannot possibly terminate normally thus its >>>>>>>>>>>>>>>>>>>> isomorphism of ⟨Ĥ⟩ correctly
simulated by embedded_H cannot possibly terminate >>>>>>>>>>>>>>>>>>>> normally.

Are you going to keep playing the fool on this? >>>>>>>>>>>>>>>>>>>>

Except that you are answering the wrong question. >>>>>>>>>>>>>>>>>>>

In other words you want to keep playing the fool and >>>>>>>>>>>>>>>>>> dodging the actual question that I am actually asking. >>>>>>>>>>>>>>>>>

No, you are showing yourself to be the fool by not >>>>>>>>>>>>>>>>> understand your own stupidity.

So you agreed that D correctly simulated H cannot >>>>>>>>>>>>>>>>>> possibly terminate
normally and the exact same thing goes for ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>> correctly simulated by
embedded_H.

No, I am saying that H can not correctly simulate the >>>>>>>>>>>>>>>>> input H and give an answer. If H DOES try to correctly >>>>>>>>>>>>>>>>> simulate its input, then it can never giv an answer. >>>>>>>>>>>>>>>>

Since you already acknowledged that D correctly >>>>>>>>>>>>>>>> simulated by H can never
terminate normally and you did not need an infinite >>>>>>>>>>>>>>>> amount of time to
determine this then the isomorphic ⟨Ĥ⟩ correctly >>>>>>>>>>>>>>>> simulated by embedded_H
can also be determined to never terminate normally and this >>>>>>>>>>>>>>>> determination can be made in a finite amount of time. >>>>>>>>>>>>>>>>
In both cases this can be correctly determined after N >>>>>>>>>>>>>>>> steps of
simulation thus no need for the infinite simulation that >>>>>>>>>>>>>>>> you keep
insisting is necessary.

You keep on LYING about what I said. Any H that gives an >>>>>>>>>>>>>>> answer can not "Correctly Simulate" this input per the >>>>>>>>>>>>>>> definitions that allow simulation to replace the behavior >>>>>>>>>>>>>>> of the actual machine.

Since you already acknowledged that D correctly simulated >>>>>>>>>>>>>> by H cannot
possibly terminate normally (hence [key agreement]) and >>>>>>>>>>>>>> the H/D pair is
isomorphic to the embedded_H / ⟨Ĥ⟩ pair you contradict >>>>>>>>>>>>>> yourself.

So?

D(D) / Ĥ (Ĥ) still halt since H returns non-halting, thus >>>>>>>>>>>>> that answer is wrong for the Halting Problem.

It only seems wrong because all of the textbooks reject >>>>>>>>>>>> simulating
halt deciders out-of-hand without review incorrectly
assuming that
simulation cannot possibly be used as the basis of a halt >>>>>>>>>>>> decider:

No, it is wrong because the question asks about the actual >>>>>>>>>>> machine, and that halts, so the right answer is HALTING. >>>>>>>>>>>

Yet any theory of computation computer scientist knows that a >>>>>>>>>> simulation
of N steps by a UTM does provide that actual behavior of the >>>>>>>>>> actual
input to this UTM.

Nope, only if the machine reaches a final state in that Nth Step. >>>>>>>>>
You just don't understand what a UTM is or what it does.

They also know that when the input to this UTM is defined to >>>>>>>>>> have a
pathological relationship to this UTM that this changes the >>>>>>>>>> behavior of
this correctly simulated input.

Nope, a UTM simulation is only correct if it exactly matches >>>>>>>>> the FULL b4ehavior of the machine it is looking at. That is its >>>>>>>>> DEFINITION.

Maybe I should begin my paper with this self-evident truth before >>>>>>>>>> proceeding to the notion of a simulating halt decider.

Yes, do that, so anyone who actually understand the theory
knows from that start that you are a crackpot.

In any case the perfect isomorphism between H/D and embedded_H >>>>>>>>>> / ⟨Ĥ⟩
already fully proves this point.

Why, since neither H or embedded_H are actually UTMs, and it is >>>>>>>>> establishied that both of them declare their input to be
non-halting when the machine they are given the description of >>>>>>>>> Halt.

*Clearly you are clueless about what the term isomorphism means* >>>>>>>> Both D and ⟨Ĥ⟩ have the exact same form in that both D and ⟨Ĥ⟩
attempt to
do the opposite of whatever their corresponding halt decider
determines.

Both of them loop when their halt decider returns {halts} and
both halt
when their halt decider returns {non-halting}. Both of them
continue to
call the halt decider in recursive simulation until their halt >>>>>>>> decider
stops simulating them.

Right, so since the Halt Decider must have a defined behavior
when given them as an input, that defined behavior will always be >>>>>>> wrong, because no matter how you define your H, the machines will >>>>>>> act the other way. This is what proves that there can't be a
decider that gets all input right.

I did not say that precisely enough.

Both of the simulated inputs [WOULD] loop if their corresponding halt >>>>>> decider [WOULD] return {halts} to them and [WOULD] halt loop if their >>>>>> corresponding halt decider [WOULD] return {non-halting} to them
yet the
actual case is that they remain stuck in recursive simulation until >>>>>> their corresponding halt decider stops simulating them.

Thus as you admitted for the H/D pair also applies to the
embedded_H / ⟨Ĥ⟩ pair. The simulated input cannot possibly terminate
normally because it remains stuck in recursive simulation until the >>>>>> simulation is terminated *IN BOTH CASES*

You seem to be acting like the HBO Westworld character Bernard that
was
a robot (AKA host) was almost perfectly a very smart human except that >>>>> his brain was hard-wired to not be able to "see" a specific door.

Then, once they're inside the dark house where Ford's robotic family >>>>> lives, Theresa asks what's behind one of the doors. "What door?"
Bernard
asks, and that's when you know he's a host as well. The door is
plain as
day, even in the dark, and he's been there before. And yet, he
couldn't
see it.

https://www.forbes.com/sites/erikkain/2016/11/14/one-of-the-biggest-westworld-fan-theories-just-came-true/?sh=5bcd83a38a3e

So, where do Main -> H(D,D) and main -> D(D) -> H(D,D) differ in
their execution path?

You claim they differ, so show it.

If you really do know software engineering then you already know on the
basis that you already agreed that D simulated by H cannot terminate
normally.

Yes, but the question isn't what does the (partial) simulation by H
show, but what does the machine repesented by the input do.

Since H doesn't simulate all of the behavior of D, its simulation
doesn't directly prove that answer.

When you ask a question that you already know the answer to then you are >>> only playing head games.

Excdpt what the simulation by H does isn't the question that H is
supposed to be answering.

That, or you are claiming that a "Correct Simulation" can differ
from the actual machine behavior, despite that going against the
definition.

You already admitted that D simulated by H never terminates normally.
Thus you knew that H is correct to abort its simulation of D to prevent
its own infinite execution.

H is allowed to abort its simulation for any reason its programmer
wants. It still needs to give the right answer to be correct, and that
answer needs to describe the behavior of directly running the machine
given an input.

Since H(D,D) has been said to return 0, we can by simple inspection,
and verify by actually running it, see that D(D) will Halt, which
means that H's answer is just wrong.

It might be a correct POOP decider, but only you seem interested in
your POOP.

The reason that I did this concretely in C is the there is no wiggle
room of ambiguity to deny what is actually occurring.

My way results in a halt decider that recognizes the actual behavior of
the actual input so that it doesn't get stuck in recursive simulation.

No, becase the ACTUAL BEHAVIOR of the machine in question is what it
does when actually run.

Since H doesn't do a simulation that meets the ACTUAL requirements of a
UTM, it results don't count.

Since D(D) Halts, H(D,D) returning zero CAN'T be correct.

All you have done is solved a Strawman Problem, which isn't a solution
to the problem in question.

You way simply denies the reality actual behavior of the actual input
and gets stuck in infinite recursion.

The ACTUAL BEHAVIOR is DEFINED as what the ACTUAL MACHINE does.

IT HALT.

THUS H IS WRONG.

You are just living in a world of lies.

When a simulating halt decider
(a) H correctly simulates N steps of its input D until
(b) H correctly determines that its simulated D would never stop running unless aborted then
(c) H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.

Nope. Just a Strawman, since H never CORRECTLY does any of those things.

I guess that is your problem, you don't understand what is Truth, so you
don't understand what is CORRECT.

You are just living in a pathological world of Pathological lies.

Nither is there in Turing Machines.

I guess "Correct Reasoning" isn't something you use yourself, just
that you argue that others don't do.

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

XPost: comp.theory, sci.logic

On 5/23/2023 7:38 PM, Richard Damon wrote:

On 5/23/23 9:50 AM, olcott wrote:

On 5/23/2023 6:44 AM, Richard Damon wrote:

On 5/22/23 11:31 PM, olcott wrote:

On 5/22/2023 10:12 PM, Richard Damon wrote:

On 5/22/23 10:49 PM, olcott wrote:

On 5/22/2023 9:27 PM, olcott wrote:

On 5/22/2023 9:02 PM, Richard Damon wrote:

On 5/22/23 9:33 PM, olcott wrote:

On 5/22/2023 6:22 PM, Richard Damon wrote:

On 5/22/23 10:22 AM, olcott wrote:

On 5/21/2023 2:02 PM, Richard Damon wrote:

On 5/21/23 2:50 PM, olcott wrote:

On 5/21/2023 1:39 PM, Richard Damon wrote:

On 5/21/23 2:12 PM, olcott wrote:

On 5/21/2023 11:54 AM, Richard Damon wrote:

On 5/21/23 10:16 AM, olcott wrote:

On 5/20/2023 6:52 PM, Richard Damon wrote:

On 5/20/23 5:29 PM, olcott wrote:

On 5/20/2023 4:24 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 5/20/23 5:10 PM, olcott wrote:

On 5/20/2023 3:48 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 5/20/23 4:33 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 2:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 3:29 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 1:54 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 2:46 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 1:15 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 1:09 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 11:10 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 11:24 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 10:19 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 10:54 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2023 8:49 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/23 12:00 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 10:27 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:

On 5/19/23 11:00 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 9:51 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:10 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 8:56 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 9:47 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/2023 5:54 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/19/23 10:50 AM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Wrong Question! >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> In other words the question is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> over you head. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It took me many years to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recognize this same dodge by Ben. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, it is the WRONG question >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> once you try to apply the answer >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to the Halting Problem, which >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you do. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

So the software engineering >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> really is over your head? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I see, so like Ben you have never >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually written any code. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

But you aren't talking about >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Software Engineering unless you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are lying about this applying to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the Halting Problem described by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Linz, since that is the Halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Problem of Computability Theory. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Of course, the likely explanation >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is that you are just ignorant of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what you are talking about, so you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> don't understand the diference. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Ben kept masking his coding >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incompetence this way. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It never occurred to me that you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have never written any code. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

I have possibly written more >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> WORKING code than you have. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

I don't believe you. Your inability >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to answer an straight forward >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> software engineering question seems >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to prove otherwise. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

What software engineering question? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Can D simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

The answer to that question is NO, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Finally you admit an easily verified fact. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

but that is because H doesn't, and can >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never do an accurarte simulation per >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the definition of a UTM. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

If the simulation by a UTM would be >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong then you would have to be able >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to point out the mistake in the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of D by H, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

No, the simulation by a ACTUAL UTM will >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach a final state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

I don't know why you say this when you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> already know that ⟨Ĥ⟩ correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by embedded_H cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Because embedded_H doesn't actually >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "Correctly Simulate" its input by the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definintion aquired by your mentioning of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a UTM.

You have already agreed that it does >>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulate the first N steps >>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly. It is just as obvious that the >>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern of N steps of >>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ correctly simulated by embedded_H >>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly terminate normally >>>>>>>>>>>>>>>>>>>>>>>>>>>>> even if the value of N is ∞. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>

But N steps in not ALL steps as required by >>>>>>>>>>>>>>>>>>>>>>>>>>>> the actual definition of a UTM. >>>>>>>>>>>>>>>>>>>>>>>>>>>>

Actually N steps is the exact definition of a >>>>>>>>>>>>>>>>>>>>>>>>>>> UTM for those N steps.
Just like with the H/D example after N steps >>>>>>>>>>>>>>>>>>>>>>>>>>> we can see that neither
D correctly simulated by H nor ⟨Ĥ⟩ correctly >>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by embedded_H
can possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>

Nope, UTMs have no concept of only doing a >>>>>>>>>>>>>>>>>>>>>>>>>> partial simulation.

When a simulating halt decider correctly >>>>>>>>>>>>>>>>>>>>>>>>> simulates N steps of its input >>>>>>>>>>>>>>>>>>>>>>>>> it derives the exact same N steps that a pure >>>>>>>>>>>>>>>>>>>>>>>>> UTM would derive because
it is itself a UTM with extra features. >>>>>>>>>>>>>>>>>>>>>>>>>

Just like a racing car is a street legal care >>>>>>>>>>>>>>>>>>>>>>>> with extra features that makes it no longer >>>>>>>>>>>>>>>>>>>>>>>> street legal.

The fact that H aborts its simulation part way >>>>>>>>>>>>>>>>>>>>>>>> means it is no longer a UTM

*Yet only at the point where it aborts its >>>>>>>>>>>>>>>>>>>>>>> simulation*

Right, but that affect the behavior of ALL copies >>>>>>>>>>>>>>>>>>>>>> of it, since they all act the same. >>>>>>>>>>>>>>>>>>>>>>
Do you think you are immortal because you haven't >>>>>>>>>>>>>>>>>>>>>> died yet, and that everyone is immortal until the >>>>>>>>>>>>>>>>>>>>>> point in time they die?

Since it just proves it isn't a UTM, it can't >>>>>>>>>>>>>>>>>>>>>> assume that the copy it is simulating is, it needs >>>>>>>>>>>>>>>>>>>>>> to account for that behavior.

The fact that the DESIGN logic to do this goes >>>>>>>>>>>>>>>>>>>>>> into an infinite loop, doesn't mean that the >>>>>>>>>>>>>>>>>>>>>> program itself does.

Since H aborts its simulation and returns 0, its >>>>>>>>>>>>>>>>>>>>>> input will see its copy do exactly the same thing >>>>>>>>>>>>>>>>>>>>>> and thus will Halt, making the answer wrong. >>>>>>>>>>>>>>>>>>>>>>
Since H isn't a UTM, since if fails to meet the >>>>>>>>>>>>>>>>>>>>>> defintion, the fact that it can't reach a final >>>>>>>>>>>>>>>>>>>>>> state is irrelevent, as is any definiton of >>>>>>>>>>>>>>>>>>>>>> "Correct Simulation" that differs from what a UTM >>>>>>>>>>>>>>>>>>>>>> does.

UTM(D,D) Halts, therefore the CORRECT SIMULATION >>>>>>>>>>>>>>>>>>>>>> (by a UTM which is what is allowed to replace the >>>>>>>>>>>>>>>>>>>>>> actual behavior of the machine) Halts, and thus >>>>>>>>>>>>>>>>>>>>>> the CORRECT answer is Halting.

You are just showing that you have fallen for your >>>>>>>>>>>>>>>>>>>>>> own Strawman Deception that got you to use the >>>>>>>>>>>>>>>>>>>>>> wrong criteria.

At this point where it aborts its simulation we >>>>>>>>>>>>>>>>>>>>>>> can see that it must
do this to prevent its own infinite execution, >>>>>>>>>>>>>>>>>>>>>>> thus conclusively proving
that it correctly determined that its simulated >>>>>>>>>>>>>>>>>>>>>>> input cannot possibly
terminate normally.

How much longer are you going to play the fool >>>>>>>>>>>>>>>>>>>>>>> and deny this?

No, it does so because it has been programmed to >>>>>>>>>>>>>>>>>>>>>> do so, and thus ALL copies of it will do so. >>>>>>>>>>>>>>>>>>>>>>
It makes the error assuming that the copy it is >>>>>>>>>>>>>>>>>>>>>> simulating will do something different than it does. >>>>>>>>>>>>>>>>>>>>>

It makes no error. As you already admitted D >>>>>>>>>>>>>>>>>>>>> correctly simulated by H
cannot possibly terminate normally thus its >>>>>>>>>>>>>>>>>>>>> isomorphism of ⟨Ĥ⟩ correctly
simulated by embedded_H cannot possibly terminate >>>>>>>>>>>>>>>>>>>>> normally.

Are you going to keep playing the fool on this? >>>>>>>>>>>>>>>>>>>>>

Except that you are answering the wrong question. >>>>>>>>>>>>>>>>>>>>

In other words you want to keep playing the fool and >>>>>>>>>>>>>>>>>>> dodging the actual question that I am actually asking. >>>>>>>>>>>>>>>>>>

No, you are showing yourself to be the fool by not >>>>>>>>>>>>>>>>>> understand your own stupidity.

So you agreed that D correctly simulated H cannot >>>>>>>>>>>>>>>>>>> possibly terminate
normally and the exact same thing goes for ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>> correctly simulated by
embedded_H.

No, I am saying that H can not correctly simulate the >>>>>>>>>>>>>>>>>> input H and give an answer. If H DOES try to correctly >>>>>>>>>>>>>>>>>> simulate its input, then it can never giv an answer. >>>>>>>>>>>>>>>>>

Since you already acknowledged that D correctly >>>>>>>>>>>>>>>>> simulated by H can never
terminate normally and you did not need an infinite >>>>>>>>>>>>>>>>> amount of time to
determine this then the isomorphic ⟨Ĥ⟩ correctly >>>>>>>>>>>>>>>>> simulated by embedded_H
can also be determined to never terminate normally and >>>>>>>>>>>>>>>>> this
determination can be made in a finite amount of time. >>>>>>>>>>>>>>>>>
In both cases this can be correctly determined after N >>>>>>>>>>>>>>>>> steps of
simulation thus no need for the infinite simulation >>>>>>>>>>>>>>>>> that you keep
insisting is necessary.

You keep on LYING about what I said. Any H that gives an >>>>>>>>>>>>>>>> answer can not "Correctly Simulate" this input per the >>>>>>>>>>>>>>>> definitions that allow simulation to replace the >>>>>>>>>>>>>>>> behavior of the actual machine.

Since you already acknowledged that D correctly simulated >>>>>>>>>>>>>>> by H cannot
possibly terminate normally (hence [key agreement]) and >>>>>>>>>>>>>>> the H/D pair is
isomorphic to the embedded_H / ⟨Ĥ⟩ pair you contradict >>>>>>>>>>>>>>> yourself.

So?

D(D) / Ĥ (Ĥ) still halt since H returns non-halting, thus >>>>>>>>>>>>>> that answer is wrong for the Halting Problem.

It only seems wrong because all of the textbooks reject >>>>>>>>>>>>> simulating
halt deciders out-of-hand without review incorrectly >>>>>>>>>>>>> assuming that
simulation cannot possibly be used as the basis of a halt >>>>>>>>>>>>> decider:

No, it is wrong because the question asks about the actual >>>>>>>>>>>> machine, and that halts, so the right answer is HALTING. >>>>>>>>>>>>

Yet any theory of computation computer scientist knows that a >>>>>>>>>>> simulation
of N steps by a UTM does provide that actual behavior of the >>>>>>>>>>> actual
input to this UTM.

Nope, only if the machine reaches a final state in that Nth Step. >>>>>>>>>>
You just don't understand what a UTM is or what it does.

They also know that when the input to this UTM is defined to >>>>>>>>>>> have a
pathological relationship to this UTM that this changes the >>>>>>>>>>> behavior of
this correctly simulated input.

Nope, a UTM simulation is only correct if it exactly matches >>>>>>>>>> the FULL b4ehavior of the machine it is looking at. That is >>>>>>>>>> its DEFINITION.

Maybe I should begin my paper with this self-evident truth >>>>>>>>>>> before
proceeding to the notion of a simulating halt decider.

Yes, do that, so anyone who actually understand the theory >>>>>>>>>> knows from that start that you are a crackpot.

In any case the perfect isomorphism between H/D and
embedded_H / ⟨Ĥ⟩
already fully proves this point.

Why, since neither H or embedded_H are actually UTMs, and it >>>>>>>>>> is establishied that both of them declare their input to be >>>>>>>>>> non-halting when the machine they are given the description of >>>>>>>>>> Halt.

*Clearly you are clueless about what the term isomorphism means* >>>>>>>>> Both D and ⟨Ĥ⟩ have the exact same form in that both D and ⟨Ĥ⟩
attempt to
do the opposite of whatever their corresponding halt decider >>>>>>>>> determines.

Both of them loop when their halt decider returns {halts} and >>>>>>>>> both halt
when their halt decider returns {non-halting}. Both of them
continue to
call the halt decider in recursive simulation until their halt >>>>>>>>> decider
stops simulating them.

Right, so since the Halt Decider must have a defined behavior
when given them as an input, that defined behavior will always >>>>>>>> be wrong, because no matter how you define your H, the machines >>>>>>>> will act the other way. This is what proves that there can't be >>>>>>>> a decider that gets all input right.

I did not say that precisely enough.

Both of the simulated inputs [WOULD] loop if their corresponding >>>>>>> halt
decider [WOULD] return {halts} to them and [WOULD] halt loop if
their
corresponding halt decider [WOULD] return {non-halting} to them
yet the
actual case is that they remain stuck in recursive simulation until >>>>>>> their corresponding halt decider stops simulating them.

Thus as you admitted for the H/D pair also applies to the
embedded_H / ⟨Ĥ⟩ pair. The simulated input cannot possibly terminate
normally because it remains stuck in recursive simulation until the >>>>>>> simulation is terminated *IN BOTH CASES*

You seem to be acting like the HBO Westworld character Bernard
that was
a robot (AKA host) was almost perfectly a very smart human except
that
his brain was hard-wired to not be able to "see" a specific door.

Then, once they're inside the dark house where Ford's robotic family >>>>>> lives, Theresa asks what's behind one of the doors. "What door?"
Bernard
asks, and that's when you know he's a host as well. The door is
plain as
day, even in the dark, and he's been there before. And yet, he
couldn't
see it.

https://www.forbes.com/sites/erikkain/2016/11/14/one-of-the-biggest-westworld-fan-theories-just-came-true/?sh=5bcd83a38a3e

So, where do Main -> H(D,D) and main -> D(D) -> H(D,D) differ in
their execution path?

You claim they differ, so show it.

If you really do know software engineering then you already know on the >>>> basis that you already agreed that D simulated by H cannot terminate
normally.

Yes, but the question isn't what does the (partial) simulation by H
show, but what does the machine repesented by the input do.

Since H doesn't simulate all of the behavior of D, its simulation
doesn't directly prove that answer.

When you ask a question that you already know the answer to then you
are
only playing head games.

Excdpt what the simulation by H does isn't the question that H is
supposed to be answering.

That, or you are claiming that a "Correct Simulation" can differ
from the actual machine behavior, despite that going against the
definition.

You already admitted that D simulated by H never terminates normally.
Thus you knew that H is correct to abort its simulation of D to prevent >>>> its own infinite execution.

H is allowed to abort its simulation for any reason its programmer
wants. It still needs to give the right answer to be correct, and
that answer needs to describe the behavior of directly running the
machine given an input.

Since H(D,D) has been said to return 0, we can by simple inspection,
and verify by actually running it, see that D(D) will Halt, which
means that H's answer is just wrong.

It might be a correct POOP decider, but only you seem interested in
your POOP.

The reason that I did this concretely in C is the there is no wiggle
room of ambiguity to deny what is actually occurring.

My way results in a halt decider that recognizes the actual behavior of
the actual input so that it doesn't get stuck in recursive simulation.

No, becase the ACTUAL BEHAVIOR of the machine in question is what it
does when actually run.

Since H doesn't do a simulation that meets the ACTUAL requirements of a
UTM, it results don't count.

Since D(D) Halts, H(D,D) returning zero CAN'T be correct.

All you have done is solved a Strawman Problem, which isn't a solution
to the problem in question.

You way simply denies the reality actual behavior of the actual input
and gets stuck in infinite recursion.

The ACTUAL BEHAVIOR is DEFINED as what the ACTUAL MACHINE does.

You keep insisting on staying out-of-sync by one recursive invocation.

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

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