On 2/10/22 9:18 AM, olcott wrote:Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
; I explain how I am necessarily correct on the basis of the meaningof my
words and you disagree on the basis of your failure to correctly
understand the meaning of these words.
No, you CLAIM to explain based on the meaning of the words, but use the
wrong meaning of the words.
THIS IS PROVEN TO BE COMPLETELY TRUE ENTIRELY ON THE BASIS OF THE
MEANING OF ITS WORDS:
When a simulating halt decider correctly determines in a finite number
of steps that the pure UTM simulation of its input would never reach
the final state of this input then it can correctly reject this input
as non-halting.
IF it correctly decided, then yes.
But it has been shown, by the definition of the construction method of
H^ that if H <H^> <H^> goes to H.Qn then H^ <H^> goes to H^.Qn and
Halts, and thus by the definition of a UTM, then we also have that UTM
<H^> <H^> will halt.
On 2/10/22 10:58 PM, olcott wrote:
On 2/10/2022 6:02 PM, Richard Damon wrote:
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
On 2/10/22 9:18 AM, olcott wrote:
> I explain how I am necessarily correct on the basis of the
meaning of my
words and you disagree on the basis of your failure to correctly
understand the meaning of these words.
No, you CLAIM to explain based on the meaning of the words, but use
the wrong meaning of the words.
THIS IS PROVEN TO BE COMPLETELY TRUE ENTIRELY ON THE BASIS OF THE
MEANING OF ITS WORDS:
When a simulating halt decider correctly determines in a finite
number of steps that the pure UTM simulation of its input would
never reach the final state of this input then it can correctly
reject this input as non-halting.
IF it correctly decided, then yes.
But it has been shown, by the definition of the construction method
of H^ that if H <H^> <H^> goes to H.Qn then H^ <H^> goes to H^.Qn and
Halts, and thus by the definition of a UTM, then we also have that
UTM <H^> <H^> will halt.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
You keep getting confused between two things:
(1) The execution of Ĥ ⟨Ĥ⟩ versus
embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ (we only look at the latter).
No, YOU qre confused.
By the definioon of how to build H^, embedded_H MUST be EXACTLY the same algorithm as H,
On 2/10/22 11:39 PM, olcott wrote:
On 2/10/2022 10:20 PM, Richard Damon wrote:
On 2/10/22 10:58 PM, olcott wrote:
On 2/10/2022 6:02 PM, Richard Damon wrote:
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
On 2/10/22 9:18 AM, olcott wrote:
> I explain how I am necessarily correct on the basis of the
meaning of my
words and you disagree on the basis of your failure to correctly
understand the meaning of these words.
No, you CLAIM to explain based on the meaning of the words, but use
the wrong meaning of the words.
THIS IS PROVEN TO BE COMPLETELY TRUE ENTIRELY ON THE BASIS OF THE
MEANING OF ITS WORDS:
When a simulating halt decider correctly determines in a finite
number of steps that the pure UTM simulation of its input would
never reach the final state of this input then it can correctly
reject this input as non-halting.
IF it correctly decided, then yes.
But it has been shown, by the definition of the construction method
of H^ that if H <H^> <H^> goes to H.Qn then H^ <H^> goes to H^.Qn
and Halts, and thus by the definition of a UTM, then we also have
that UTM <H^> <H^> will halt.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
You keep getting confused between two things:
(1) The execution of Ĥ ⟨Ĥ⟩ versus
embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ (we only look at the latter).
No, YOU qre confused.
By the definioon of how to build H^, embedded_H MUST be EXACTLY the
same algorithm as H,
No it is specifically not allowed to be.
embedded_H must have an infinite loop appended to its Ĥ.qy state and H
is not allowed to have such a loop appended to its H.qy state.
Which is OUTSIDE the algorithm of H itself, and doesn't affect the
behavior of H in deciding to go from Q0 to Qy/Qn.
On 2/12/22 9:08 AM, olcott wrote:
On 2/12/2022 6:49 AM, Richard Damon wrote:
I am agreeing that you contradicted yourself.
On 2/12/22 12:01 AM, olcott wrote:
On 2/11/2022 10:50 PM, Richard Damon wrote:
On 2/11/22 11:36 PM, olcott wrote:
On 2/11/2022 6:58 PM, Richard Damon wrote:
On 2/11/22 7:52 PM, olcott wrote:
On 2/11/2022 6:17 PM, Richard Damon wrote:
On 2/11/22 7:10 PM, olcott wrote:
On 2/11/2022 5:36 PM, Richard Damon wrote:
On 2/11/22 10:20 AM, olcott wrote:The fact that it is not an exact copy makes a difference.
On 2/11/2022 5:36 AM, Richard Damon wrote:
On 2/10/22 11:39 PM, olcott wrote:When the simulating halt decider bases it halt status
On 2/10/2022 10:20 PM, Richard Damon wrote:
On 2/10/22 10:58 PM, olcott wrote:
On 2/10/2022 6:02 PM, Richard Damon wrote:No, YOU qre confused.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>>>>>>>>>>>>>
On 2/10/22 9:18 AM, olcott wrote:
> I explain how I am necessarily correct on the basis >>>>>>>>>>>>>>>>> of the meaning of my
words and you disagree on the basis of your failure to >>>>>>>>>>>>>>>>>> correctly understand the meaning of these words. >>>>>>>>>>>>>>>>>No, you CLAIM to explain based on the meaning of the >>>>>>>>>>>>>>>>> words, but use the wrong meaning of the words. >>>>>>>>>>>>>>>>>
THIS IS PROVEN TO BE COMPLETELY TRUE ENTIRELY ON THE >>>>>>>>>>>>>>>>>> BASIS OF THE MEANING OF ITS WORDS:
When a simulating halt decider correctly determines in >>>>>>>>>>>>>>>>>> a finite number of steps that the pure UTM simulation >>>>>>>>>>>>>>>>>> of its input would never reach the final state of this >>>>>>>>>>>>>>>>>> input then it can correctly reject this input as >>>>>>>>>>>>>>>>>> non-halting.
IF it correctly decided, then yes.
But it has been shown, by the definition of the >>>>>>>>>>>>>>>>> construction method of H^ that if H <H^> <H^> goes to >>>>>>>>>>>>>>>>> H.Qn then H^ <H^> goes to H^.Qn and Halts, and thus by >>>>>>>>>>>>>>>>> the definition of a UTM, then we also have that UTM >>>>>>>>>>>>>>>>> <H^> <H^> will halt.
You keep getting confused between two things:
(1) The execution of Ĥ ⟨Ĥ⟩ versus
embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ (we only look at the latter). >>>>>>>>>>>>>>>
By the definioon of how to build H^, embedded_H MUST be >>>>>>>>>>>>>>> EXACTLY the same algorithm as H,
No it is specifically not allowed to be.
embedded_H must have an infinite loop appended to its Ĥ.qy >>>>>>>>>>>>>> state and H is not allowed to have such a loop appended to >>>>>>>>>>>>>> its H.qy state.
Which is OUTSIDE the algorithm of H itself, and doesn't >>>>>>>>>>>>> affect the behavior of H in deciding to go from Q0 to Qy/Qn. >>>>>>>>>>>>
decision on whether or not the same function is being called >>>>>>>>>>>> with the same inputs the difference between H and embedded_H >>>>>>>>>>>> can change the behavior. A string comparison between the >>>>>>>>>>>> machine description of H and embedded_H yields false.
No, it can't, not and be a COMPUTATION.
You obviously don't know the meaning of the words, so you are >>>>>>>>>>> just wrong.
Computation means for ALL copoies, Same input leads to Same >>>>>>>>>>> Output.
But it IS.
H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does not determine that itself is being >>>>>>>> called multiple times with the same input. embedded_H does
determine that itself is called multiple times with the same
input because strcmp(H, embedded_H != 0.
Except that embedded_H does't have a 'representation' of itself
to use to make that comparison, so that is just more of your
Fairy Dust Powered Unicorn stuff.
It can very easily have a representation of itself, that only
requires that it has access to its own machine description.
First, Turing Machines DON'T have access to their own machine
description, unless it has been provided as an input
You said that this was impossible.
So, you are agreeing that they can't? Or do you just not understand
the logic.
How, by saying that the only way a Turing Machine can have a copy of its representation is for it to be given (and H is defined in a way that it
can't be given as an extra input)?
On 2/13/22 10:30 PM, olcott wrote:So in other words you are disavowing that both ⟨Ĥ⟩ and ⟨Ḧ⟩ have a copy
On 2/13/2022 7:27 PM, Richard Damon wrote:
On 2/13/22 7:26 PM, olcott wrote:
On 2/13/2022 6:24 PM, Richard Damon wrote:
On 2/13/22 6:08 PM, olcott wrote:
On 2/13/2022 4:11 PM, Richard Damon wrote:
On 2/13/22 5:04 PM, olcott wrote:
On 2/13/2022 3:40 PM, Richard Damon wrote:
On 2/13/22 4:24 PM, olcott wrote:
On 2/13/2022 3:12 PM, Richard Damon wrote:
On 2/13/22 3:18 PM, olcott wrote:
On 2/13/2022 1:57 PM, Richard Damon wrote:
On 2/13/22 2:43 PM, olcott wrote:
On 2/13/2022 11:19 AM, Richard Damon wrote:
On 2/13/22 9:38 AM, olcott wrote:
On 2/13/2022 5:43 AM, Richard Damon wrote:
On 2/13/22 12:54 AM, olcott wrote:
On 2/12/2022 8:22 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> On 2/12/22 9:02 PM, olcott wrote:
On 2/12/2022 7:54 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>> On 2/12/22 8:27 PM, olcott wrote:
On 2/12/2022 6:57 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>> On 2/12/22 7:37 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2/12/2022 6:25 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/12/22 6:48 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2/12/2022 5:39 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/12/22 5:34 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/12/2022 8:41 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/12/22 9:08 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/12/2022 6:49 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
When I redefine Ĥ to become Ḧ by eliminating its >>>>>>>>>>>>>>>>>>>>>> infinite loop, I probably mean: {I redefine Ĥ to >>>>>>>>>>>>>>>>>>>>>> become Ḧ by eliminating its infinite loop}. >>>>>>>>>>>>>>>>>>>>>>So another words hypothetical examples get you >>>>>>>>>>>>>>>>>>>>>>>>>> so confused you totally lose track of everything. >>>>>>>>>>>>>>>>>>>>>>>>>>On 2/12/22 12:01 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/11/2022 10:50 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/11/22 11:36 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/11/2022 6:58 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
You said that this was impossible. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>On 2/11/22 7:52 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/11/2022 6:17 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/11/22 7:10 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/11/2022 5:36 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/11/22 10:20 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/11/2022 5:36 AM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/10/22 11:39 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/10/2022 10:20 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/10/22 10:58 PM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/10/2022 6:02 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/10/22 9:18 AM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> > I explain how I am >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct on the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> basis of the meaning of my >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> words and you disagree on >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the basis of your failure >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to correctly understand >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the meaning of these words. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, you CLAIM to explain >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> based on the meaning of the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> words, but use the wrong >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> meaning of the words. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THIS IS PROVEN TO BE >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> COMPLETELY TRUE ENTIRELY >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ON THE BASIS OF THE >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> MEANING OF ITS WORDS: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When a simulating halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines in a finite >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> number of steps that the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pure UTM simulation of its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input would never reach >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the final state of this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input then it can >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly reject this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input as non-halting. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IF it correctly decided, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then yes. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But it has been shown, by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the definition of the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> construction method of H^ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that if H <H^> <H^> goes to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H.Qn then H^ <H^> goes to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H^.Qn and Halts, and thus >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by the definition of a UTM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then we also have that UTM >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <H^> <H^> will halt. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢*It can very easily have a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> representation of itself, that only >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> requires that it has access to its own >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine description. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
No, it can't, not and be a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> COMPUTATION. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Ĥ.qy ∞ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢*
Ĥ.qn >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You keep getting confused >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> between two things: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) The execution of Ĥ ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> versus >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ (we only
look at the latter). >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, YOU qre confused. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> By the definioon of how to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> build H^, embedded_H MUST be >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> EXACTLY the same algorithm as H, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No it is specifically not >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> allowed to be. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H must have an >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite loop appended to its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.qy state and H is not >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> allowed to have such a loop >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> appended to its H.qy state. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Which is OUTSIDE the algorithm >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of H itself, and doesn't affect >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the behavior of H in deciding >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to go from Q0 to Qy/Qn. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When the simulating halt decider >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> bases it halt status decision on >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether or not the same function >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is being called with the same >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs the difference between H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and embedded_H can change the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior. A string comparison >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> between the machine description >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of H and embedded_H yields false. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
You obviously don't know the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> meaning of the words, so you are >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> just wrong. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Computation means for ALL >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> copoies, Same input leads to Same >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Output. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The fact that it is not an exact >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> copy makes a difference. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
But it IS. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ does not >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determine that itself is being >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> called multiple times with the same >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input. embedded_H does determine >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that itself is called multiple times >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> with the same input because >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> strcmp(H, embedded_H != 0. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Except that embedded_H does't have a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 'representation' of itself to use to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> make that comparison, so that is just >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> more of your Fairy Dust Powered >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Unicorn stuff. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
First, Turing Machines DON'T have >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> access to their own machine >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> description, unless it has been >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> provided as an input >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
So, you are agreeing that they can't? Or >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do you just not understand the logic. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I am agreeing that you contradicted yourself. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
How, by saying that the only way a Turing >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Machine can have a copy of its >>>>>>>>>>>>>>>>>>>>>>>>>>>>> representation is for it to be given (and H >>>>>>>>>>>>>>>>>>>>>>>>>>>>> is defined in a way that it can't be given >>>>>>>>>>>>>>>>>>>>>>>>>>>>> as an extra input)?
No appended infinite loop making H and >>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H the same
Ḧ.q0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy
Ḧ.q0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
embedded_H ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn >>>>>>>>>>>>>>>>>>>>>>>>>>>> H ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* H.qn >>>>>>>>>>>>>>>>>>>>>>>>>>>>
Except that the infinite loop isn't part of >>>>>>>>>>>>>>>>>>>>>>>>>>> the copy of H in H^, it is something ADD to >>>>>>>>>>>>>>>>>>>>>>>>>>> it, which only has/affects behavior AFTER H >>>>>>>>>>>>>>>>>>>>>>>>>>> makes its decision.
What 'Hypothetical' are you referencing. >>>>>>>>>>>>>>>>>>>>>>>>>
This is what I mean when I say that you hardly >>>>>>>>>>>>>>>>>>>>>>>> pay any attention at all.
This is the hypothetical that I am referencing: >>>>>>>>>>>>>>>>>>>>>>>>
No appended infinite loop making H and >>>>>>>>>>>>>>>>>>>>>>>> embedded_H the same
Ḧ.q0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy
Ḧ.q0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
And what do you mean by that?
Which does what? Since if you aren't talking about >>>>>>>>>>>>>>>>>>>>> Linz's H^, your results don't mean anything for the >>>>>>>>>>>>>>>>>>>>> Halting Problem.
It provides a bridge of understanding to my HP >>>>>>>>>>>>>>>>>>>> refutation.
The key skill that I have applied throughout my >>>>>>>>>>>>>>>>>>>> career is eliminating "inessential complexity" (1999 >>>>>>>>>>>>>>>>>>>> Turing award winner Fred Brooks) to make >>>>>>>>>>>>>>>>>>>> enormously difficult problems as simple as possible. >>>>>>>>>>>>>>>>>>>>
https://en.wikipedia.org/wiki/No_Silver_Bullet >>>>>>>>>>>>>>>>>>>>
But if you eliminate KEY ASPECTS then you aren't >>>>>>>>>>>>>>>>>>> talking about what you need to.
It is just like learning arithmetic before attacking >>>>>>>>>>>>>>>>>> algebra.
It lays the foundation of prerequisites for my actual >>>>>>>>>>>>>>>>>> rebuttal.
Just beware that if you make a statement that is only >>>>>>>>>>>>>>>>> true for a limited case and don't explicitly state so, >>>>>>>>>>>>>>>>> pointing that out is NOT a 'Dishonest Dodge'. >>>>>>>>>>>>>>>>>
Since it is know that you are working on trying to >>>>>>>>>>>>>>>>> prove that a Unicorn exists, what you are saying WILL >>>>>>>>>>>>>>>>> be looked at in a light anticipating where you are going. >>>>>>>>>>>>>>>>>
Also remember that showing a rule happens to be correct >>>>>>>>>>>>>>>>> for one case, doesn't prove that it will be for a >>>>>>>>>>>>>>>>> different case.
You have gone through all of this before, and it came >>>>>>>>>>>>>>>>> for nothing, but if this is how you want to spend your >>>>>>>>>>>>>>>>> last days, knock yourself out.
I think that you already understand that
With Ĥ ⟨Ĥ⟩
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ // this path is never
taken
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>>>>>>>>>>>>>
making Ḧ ⟨Ḧ⟩ an equivalent computation >>>>>>>>>>>>>>>> Ḧ.q0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qy >>>>>>>>>>>>>>>> Ḧ.q0 ⟨Ḧ⟩ ⊢* Ḧ.qx ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn >>>>>>>>>>>>>>>>
And, as seems common with your arguments, you keep on >>>>>>>>>>>>>>> forgetting the CONDITIONS on each line.
H^ <H^> is
H^.q0 <H^> -> H^.Qx <H^> <H^>
Then
H^.Qx <H^> <H^> -> H^.Qy -> ∞ IF and only if H <H^> <H^> >>>>>>>>>>>>>>> -> H.Qy and
H^.Qx <H^> <H^> -> H^.Qn If and ohly if H <H^> <H^> => H.Qn. >>>>>>>>>>>>>>>
If you stipulate that H <H^> <H^> will never go to H.Qy, >>>>>>>>>>>>>>> then the behavior on that path can be changed with no >>>>>>>>>>>>>>> effect.
Without the If and only if clauses, the initial
description is incorrect because it is incomplete. >>>>>>>>>>>>>>>
So, WITH THE STIPULATION THAT H won't go to H.Qy for >>>>>>>>>>>>>>> either version, then changing H^ to the H" that omits to >>>>>>>>>>>>>>> loop is an equivalence, but ONLY under that stipulation. >>>>>>>>>>>>>>>
This of course shows that H will be wrong about H", as H" >>>>>>>>>>>>>>> will ALWAYS Halt if H answers, and H not answering is >>>>>>>>>>>>>>> always wrong. Thus H will either be wrong for not >>>>>>>>>>>>>>> answering or giving the wrong answer.
I am only making two versions of input to H:
(1) Ĥ WITH an appended infinite loop
(2) Ḧ WITHOUT an appended infinite loop
Only this is being examined:
embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
embedded_H ⟨Ḧ⟩ ⟨Ḧ⟩
Right, but the conclusion that H" is 'equivalent' to H^ is >>>>>>>>>>>>> only true (if you mean equivalent in the sense that they >>>>>>>>>>>>> compute the same function) if it is the case that neither >>>>>>>>>>>>> of H <H^> <H^> or H <H"> <H"> go to H.Qy.
Good.
Unless you want to indicate some other definition of >>>>>>>>>>>>> 'equivalent' you using (that could be proper to do so >>>>>>>>>>>>> here), you need to include the conditions under which the >>>>>>>>>>>>> statement is true.
embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ḧ.qn
and
embedded_H ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
nd
H ⟨Ḧ⟩ ⟨Ḧ⟩ ⊢* Ḧ.qn
Problem, embedded_H / H need to transition to a state in H, >>>>>>>>>>> not some other machine.
As soon as we append an infinite loop to H.y is it no longer H. >>>>>>>>>>
This is where you are showing your lack of understanding of
Turing Machines.
NO ONE has said that the machine where we added the loop is
still the machine H, in fact, Linz calls that machine H', but >>>>>>>>> H' CONTAINS a complete copy of H, and that copy will still act >>>>>>>>> exactly like the original H to the point where it gets to the >>>>>>>>> stat Qy.
This ability to compose machines of copies of other machines is >>>>>>>>> basically like the concept of calling subroutines (even if it >>>>>>>>> is implemented differently) and is fundamental to the design >>>>>>>>> and analysis of Turing Macines.
Would you have a problem saying the subroutine H is no longer >>>>>>>>> the subroutine H if one function just calls H and returns while >>>>>>>>> a second calls H and conditionally loops? Yes, the whole
program is not H, but the subroutine H is still there and will >>>>>>>>> behave exactly like it used to in both of the cases.
One way to map a Turing Machine to ordinary software is to
think of the Q0 state (or whatever is the 'starting' state of >>>>>>>>> the Turing machine) as the entry point for the function, and >>>>>>>>> the Halting States of the Turing Machine as retrun stateents >>>>>>>>> which return a value indicating what state the machine ended in. >>>>>>>>>
Thus the modifications Linz has done to H are nothing more that >>>>>>>>> building H^ as mostly a call to H, with code before the call to >>>>>>>>> manipulate the tape to add the second copy, and code after the >>>>>>>>> return to loop forever if H returns the 'Halting' answer.
The Machine/Subroutine H has not been touched at all.
My point is that Ĥ ⟨Ĥ⟩ is equivalent to Ḧ ⟨Ḧ⟩
And my point is that they are only equivalent in the normal sense >>>>>>> of the word if neither of H <H^> <H^> and H <H"> <H"> go to H.Qy >>>>>>>
Without that qualification, it is a false statement. PERIOD.
They are equivalent in that neither can possibly go to their q.y
state.
THAT is incorrect without the same
qualification/assumption/stipulation, the H doesn't go to Qy.
If H was a white cat detector and you presented H with a black cat
would it say "yes" ?
But we aren't talking about a 'detector'
Sure we are.
Then you don't know what you are talking about (and showing your
dishonesty by your clipping).
THe claim that H^ and H" are equivilent machines has NOTHING to do with
there being a 'Detector' but do they behave exactly the same.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 297 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 111:42:26 |
| Calls: | 6,662 |
| Files: | 12,209 |
| Messages: | 5,335,955 |