olcott <NoOne@NoWhere.com> writes:
On 3/27/2022 6:26 PM, Ben Bacarisse wrote:
olcott <NoOne@NoWhere.com> writes:
On 3/27/2022 1:25 PM, Ben Bacarisse wrote:
olcott <NoOne@NoWhere.com> writes:
On 3/27/2022 11:00 AM, Ben Bacarisse wrote:It terminates. You do see that you've said that again and again, yes? >>>>> You can't hide a fact you keep stating explicitly.
olcott <NoOne@NoWhere.com> writes:
At least you seem to have dropped the notion of magic PO-machines. Is >>>>>>> that the mistake you wouldn't tell me about?
Ĥ.q0 ⟨Ĥ⟩ ⊦* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
HERE IS WHY THAT IS CORRECT:
The directly executed Ĥ applied to ⟨Ĥ⟩ is the first invocation of >>>>>> infinite recursion that only terminates normally because of its
one-way dependency relationship on embedded_H aborting the second
invocation of this otherwise infinite recursion.
You saw this problem with your supposed solution a while back. That's >>>>> why you invented magic PO-machines where H can behave differently to a >>>>> copy of H. Why did you do that? Because you know that Ĥ applied to ⟨Ĥ⟩
terminates and so H should accept ⟨Ĥ⟩ ⟨Ĥ⟩. > Now that you have ditched
As long as the simulated input to embedded_H could never reach its
final state in any finite number of steps of correct simulation then
its rejection of this input is necessarily correct and everything else >>>> in the universe is totally irrelevant.
The definition of the problem is not irrelevant.
TRY AND FIND ANY ERROR IN THESE EXACT WORDS:
I see you are now in full-on cut and paste mode and don't want to
discuss the points put to you. That's not a fun game. Just image that
I put the same facts to you every time you paste the same text, ok?
On Sunday, March 27, 2022 at 9:35:19 PM UTC-4, olcott wrote:
I don't even look at it because it is merely a terrible attempt at
trying to get away with the strawman error.
In other words, you can't explain it because it demonstrates quite clearly that you're incorrect.
On 3/27/22 10:04 PM, olcott wrote:
TRY AND FIND ANY ERROR IN THESE EXACT WORDS:WRONG DEFINTION OF HALTING. FAIL.
As long as the simulated input to embedded_H could never reach its
final state in any finite number of steps of correct simulation by
embedded_H then its rejection of this input is necessarily correct.
On Sunday, March 27, 2022 at 10:04:22 PM UTC-4, olcott wrote:
On 3/27/2022 8:47 PM, Dennis Bush wrote:
On Sunday, March 27, 2022 at 9:35:19 PM UTC-4, olcott wrote:Frederick Brooks - ACM Awards Turing Award (1999)
I don't even look at it because it is merely a terrible attempt at
trying to get away with the strawman error.
In other words, you can't explain it because it demonstrates quite clearly that you're incorrect.
I have always focused on Brooks advice of eliminating inessential
complexity https://en.wikipedia.org/wiki/No_Silver_Bullet
Keeping analysis down to it minimal essence makes some otherwise
impossibly complex analysis feasible.
I only focus on the embedded copy of the Linz H at Ĥ.qx because this is
what Linz bases his conclusion on.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
state.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
final state.
TRY AND FIND ANY ERROR IN THESE EXACT WORDS:
As long as the simulated input to embedded_H could never reach its final
state in any finite number of steps of correct simulation by embedded_H
then its rejection of this input is necessarily correct.
Halting problem undecidability and infinitely nested simulation (V4)
So you agree that Ha3 is correct reject the input <N><5>? Because if the above is true, then the same is true for H (since embedded_H is a copy of H) and therefore for any simulating halt decider, so this is also true:
As long as the simulated input <N><5> to Ha3 could never reach its final state in any finite number of steps of correct simulation by Ha3
then its rejection of this input is necessarily correct
On Sunday, March 27, 2022 at 10:24:33 PM UTC-4, olcott wrote:
On 3/27/2022 9:10 PM, Dennis Bush wrote:
On Sunday, March 27, 2022 at 10:04:22 PM UTC-4, olcott wrote:I agree that I am only talking about embedded_H and Ha3 is not
On 3/27/2022 8:47 PM, Dennis Bush wrote:
On Sunday, March 27, 2022 at 9:35:19 PM UTC-4, olcott wrote:Frederick Brooks - ACM Awards Turing Award (1999)
I don't even look at it because it is merely a terrible attempt at >>>>>> trying to get away with the strawman error.
In other words, you can't explain it because it demonstrates quite clearly that you're incorrect.
I have always focused on Brooks advice of eliminating inessential
complexity https://en.wikipedia.org/wiki/No_Silver_Bullet
Keeping analysis down to it minimal essence makes some otherwise
impossibly complex analysis feasible.
I only focus on the embedded copy of the Linz H at Ĥ.qx because this is >>>> what Linz bases his conclusion on.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
state.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
final state.
TRY AND FIND ANY ERROR IN THESE EXACT WORDS:
As long as the simulated input to embedded_H could never reach its final >>>> state in any finite number of steps of correct simulation by embedded_H >>>> then its rejection of this input is necessarily correct.
Halting problem undecidability and infinitely nested simulation (V4)
So you agree that Ha3 is correct reject the input <N><5>? Because if the above is true, then the same is true for H (since embedded_H is a copy of H) and therefore for any simulating halt decider, so this is also true:
embedded_H. I am also not talking about H because Linz does not use H as
the basis of his conclusion. We must stay focused on the simplest
possible essence.
Yes you are talking about H (or more accurately Ha).
On Sunday, March 27, 2022 at 10:59:01 PM UTC-4, olcott wrote:
On 3/27/2022 9:33 PM, Dennis Bush wrote:
On Sunday, March 27, 2022 at 10:24:33 PM UTC-4, olcott wrote:The behavior of ⟨Ĥ⟩ ⟨Ĥ⟩ simulated outside of Ĥ must be computationally
On 3/27/2022 9:10 PM, Dennis Bush wrote:
On Sunday, March 27, 2022 at 10:04:22 PM UTC-4, olcott wrote:I agree that I am only talking about embedded_H and Ha3 is not
On 3/27/2022 8:47 PM, Dennis Bush wrote:So you agree that Ha3 is correct reject the input <N><5>? Because if the above is true, then the same is true for H (since embedded_H is a copy of H) and therefore for any simulating halt decider, so this is also true:
On Sunday, March 27, 2022 at 9:35:19 PM UTC-4, olcott wrote:Frederick Brooks - ACM Awards Turing Award (1999)
I don't even look at it because it is merely a terrible attempt at >>>>>>>> trying to get away with the strawman error.
In other words, you can't explain it because it demonstrates quite clearly that you're incorrect.
I have always focused on Brooks advice of eliminating inessential
complexity https://en.wikipedia.org/wiki/No_Silver_Bullet
Keeping analysis down to it minimal essence makes some otherwise
impossibly complex analysis feasible.
I only focus on the embedded copy of the Linz H at Ĥ.qx because this is >>>>>> what Linz bases his conclusion on.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
state.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
final state.
TRY AND FIND ANY ERROR IN THESE EXACT WORDS:
As long as the simulated input to embedded_H could never reach its final >>>>>> state in any finite number of steps of correct simulation by embedded_H >>>>>> then its rejection of this input is necessarily correct.
Halting problem undecidability and infinitely nested simulation (V4) >>>>>
embedded_H. I am also not talking about H because Linz does not use H as >>>> the basis of his conclusion. We must stay focused on the simplest
possible essence.
Yes you are talking about H (or more accurately Ha).
equivalent to the direct execution of Ĥ applied to ⟨Ĥ⟩ yet not the same
as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated inside of Ĥ because:
The directly executed Ĥ applied to ⟨Ĥ⟩ is the first invocation of
infinite recursion that only terminates normally because of its one-way
dependency relationship on embedded_H aborting the second invocation of
this otherwise infinite recursion.
That's a convoluted way of saying that H is unable to simulate Ĥ applied to ⟨Ĥ⟩ accurately.
On 3/27/2022 10:04 PM, Dennis Bush wrote:
On Sunday, March 27, 2022 at 10:59:01 PM UTC-4, olcott wrote:
On 3/27/2022 9:33 PM, Dennis Bush wrote:
On Sunday, March 27, 2022 at 10:24:33 PM UTC-4, olcott wrote:The behavior of ⟨Ĥ⟩ ⟨Ĥ⟩ simulated outside of Ĥ must be computationally
On 3/27/2022 9:10 PM, Dennis Bush wrote:
On Sunday, March 27, 2022 at 10:04:22 PM UTC-4, olcott wrote:I agree that I am only talking about embedded_H and Ha3 is not
On 3/27/2022 8:47 PM, Dennis Bush wrote:So you agree that Ha3 is correct reject the input <N><5>? Because if the above is true, then the same is true for H (since embedded_H is a copy of H) and therefore for any simulating halt decider, so this is also true:
On Sunday, March 27, 2022 at 9:35:19 PM UTC-4, olcott wrote: >>>>>>>> I don't even look at it because it is merely a terrible attempt at >>>>>>>> trying to get away with the strawman error.Frederick Brooks - ACM Awards Turing Award (1999)
In other words, you can't explain it because it demonstrates quite clearly that you're incorrect.
I have always focused on Brooks advice of eliminating inessential >>>>>> complexity https://en.wikipedia.org/wiki/No_Silver_Bullet
Keeping analysis down to it minimal essence makes some otherwise >>>>>> impossibly complex analysis feasible.
I only focus on the embedded copy of the Linz H at Ĥ.qx because this is
what Linz bases his conclusion on.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
state.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
final state.
TRY AND FIND ANY ERROR IN THESE EXACT WORDS:
As long as the simulated input to embedded_H could never reach its final
state in any finite number of steps of correct simulation by embedded_H
then its rejection of this input is necessarily correct.
Halting problem undecidability and infinitely nested simulation (V4) >>>>>
embedded_H. I am also not talking about H because Linz does not use H as
the basis of his conclusion. We must stay focused on the simplest
possible essence.
Yes you are talking about H (or more accurately Ha).
equivalent to the direct execution of Ĥ applied to ⟨Ĥ⟩ yet not the same
as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated inside of Ĥ because:
The directly executed Ĥ applied to ⟨Ĥ⟩ is the first invocation of >> infinite recursion that only terminates normally because of its one-way >> dependency relationship on embedded_H aborting the second invocation of >> this otherwise infinite recursion.
That's a convoluted way of saying that H is unable to simulate Ĥ applied to ⟨Ĥ⟩ accurately.
A halt decider computes the mapping of its inputs to its own accept or reject state on the basis of the actual behavior specified by its input.
embedded_H does correctly simulate ⟨Ĥ⟩ ⟨Ĥ⟩ until it sees that this simulated input will never reach its own final state ⟨Ĥ.qn⟩.
--
Copyright 2022 Pete Olcott
"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer
On 3/27/22 11:00 PM, olcott wrote:
On 3/27/2022 9:29 PM, Richard Damon wrote:
On 3/27/22 10:07 PM, olcott wrote:
On 3/27/2022 8:52 PM, Richard Damon wrote:
On 3/27/22 9:27 PM, olcott wrote:
On 3/27/2022 8:19 PM, Richard Damon wrote:
On 3/27/22 9:00 PM, olcott wrote:
On 3/27/2022 7:51 PM, Richard Damon wrote:
On 3/27/22 8:36 PM, olcott wrote:
On 3/27/2022 7:33 PM, Richard Damon wrote:
On 3/27/22 8:22 PM, olcott wrote:
On 3/27/2022 6:56 PM, Richard Damon wrote:
On 3/27/22 7:37 PM, olcott wrote:That is out-of-scope. You must find an error in my exact >>>>>>>>>>>> words and explain why it is an error, otherwise we get stuck >>>>>>>>>>>> talking in circles that are various shades of the strawman >>>>>>>>>>>> error.
On 3/27/2022 6:34 PM, Dennis Bush wrote:
On Sunday, March 27, 2022 at 7:26:34 PM UTC-4, olcott wrote: >>>>>>>>>>>>>>>> On 3/27/2022 6:22 PM, Richard Damon wrote:
I told him that his question was just liked counting to >>>>>>>>>>>>>>>> ten: 1,2,3 DONE.
On 3/27/22 7:16 PM, olcott wrote:
On 3/27/2022 6:05 PM, Dennis Bush wrote:
On Sunday, March 27, 2022 at 6:55:02 PM UTC-4, olcott >>>>>>>>>>>>>>>>>>> wrote:
On 3/27/2022 5:47 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 6:43:43 PM UTC-4, >>>>>>>>>>>>>>>>>>>>> olcott wrote:I want to hear your answer. What criteria do you use >>>>>>>>>>>>>>>>>>> to show that
That is an intentionally stupid question. >>>>>>>>>>>>>>>>>>>On 3/27/2022 5:38 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 6:12:47 PM UTC-4, >>>>>>>>>>>>>>>>>>>>>>> olcott wrote:So Ha3 is obviously wrong? What criteria do you use >>>>>>>>>>>>>>>>>>>>> to determine that?
That is ridiculously stupid.On 3/27/2022 3:50 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 4:40:59 PM UTC-4, >>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:Sure there is, I defined them earlier. But just >>>>>>>>>>>>>>>>>>>>>>> so there's no
There is no H3, <N> or <3>. There is an ⟨Ĥ3⟩ >>>>>>>>>>>>>>>>>>>>>>>On 3/27/2022 3:24 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 3:35:17 PM >>>>>>>>>>>>>>>>>>>>>>>>>>> UTC-4, olcott wrote:
That is a common misconception. Please read my >>>>>>>>>>>>>>>>>>>>>>>>>> paper.On 3/27/2022 2:23 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/22 2:56 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/2022 1:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/22 2:44 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/2022 1:42 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/22 2:22 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/2022 1:17 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
On 3/27/22 1:44 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/27/2022 11:20 AM, Ben Bacarisse >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
On 3/26/2022 7:30 PM, Ben >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Bacarisse wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>You don't get to say what the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting problem is. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It's already >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> been >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specified. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
what the correct answer for it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is, is determined >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> solely by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether or >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not Ĥ halts on input ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>That is not true. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Every string either represents a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computation or it does >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> There is no context other than some >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prior agreed >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encoding about >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> how a TM >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and an input should be represented. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A halt decide >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must accept >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exactly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> those strings that represent >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting computations. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The fact that you need to reject >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the very >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definition of the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> clear evidence that you know that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> no TM is a halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
This is true: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>It does not matter why the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computation represented >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a particular >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> string >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts. You've been trying to pull >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this "it only >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts because" >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> nonsense >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for years. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The directly executed Ĥ applied to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ is the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> first invocation of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite recursion that only >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminates normally >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because of its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> one-way dependency relationship on >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborting the second >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> invocation of this otherwise >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite recursion. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
As long as the simulated input to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H could >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never reach >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final state in any finite number >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of steps of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation then its rejection of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this input is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and everything else in the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> universe is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> totally irrelevant. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
A halt decider must compute the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mapping from its >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inputs (not >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> anything else in the universe >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> besides it inputs) to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its own >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> accept or reject state based on the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual behavior >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specified by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> these actual inputs (not any >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of anything >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> else in the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> universe). >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
We also know that the actual >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior specified by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> these inputs >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must be the same as the behavior of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of N steps of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this input by a UTM. On this basis >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> we know that any >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that diverges from this behavior is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not the correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> basis for >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the halt status decision. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The string ⟨Ĥ⟩ ⟨Ĥ⟩ represents someIf it is simulated outside of Ĥ then >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it must have >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior as Ĥ applied to ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
computation. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
If it is simulated inside of Ĥ then >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> several steps of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ have >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> already been executed when this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation begins thus >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specifying a different sequence of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> configurations >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then when Ĥ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> starts at its beginning. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
I assume you have not >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> been deceiving us for years, and >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you know that the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computation it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> represents is Ĥ applied to the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> string ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>When Ĥ is simulated in the middle of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ this is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> different than >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when Ĥ is simulated at the beginning >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of Ĥ. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
That either is or is not a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting computation. There is no >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> context-dependence >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (other >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> than the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>void Infinite_Recursion(int N) >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
Infinite_Recursion(N); >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
It is obvious that the above >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sequence is infinitely >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the halt decider aborts the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> second recursive call >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> first recursive call would halt. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That the first >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursive call >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts does not indicate that it is a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> computation. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
agreed encoding). There is no >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dispensation from >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "special" >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> kinds of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Don't you think that having to have >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> these sort of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> basic matter >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> explained >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to you, year in, year out, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> indicates that maybe you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> should be >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doing >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> something else? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
YOU ARE UNABLE TO GRASP THAT THIS IS >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> NECESSARY TRUE. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU ARE UNABLE TO GRASP THAT THIS IS >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> NECESSARY TRUE. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU ARE UNABLE TO GRASP THAT THIS IS >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> NECESSARY TRUE. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU ARE UNABLE TO GRASP THAT THIS IS >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> NECESSARY TRUE. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> YOU ARE UNABLE TO GRASP THAT THIS IS >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> NECESSARY TRUE. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
As long as the simulated input to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H could >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never reach >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its final state in any finite number >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of steps of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation then its rejection of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this input is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and everything else in the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> universe is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> totally irrelevant. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
No, YOU do not grasp that the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> definitions that were >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> established >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ARE the definitions you need to use, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Because a halt decider must compute >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the mapping from >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input
finite strings based on the actual >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior specified >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by these
strings which is correctly measured by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a correct
simulation of N >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps of these strings you already >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> know that I am >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct.
Nope, wrong definition, wrong answer. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Do you have a reference for adding the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 'of N steps' >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> into the
definition?
N = "simulating it for as many steps as >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it will take"
So might be infinite, and thus H fails to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer in
finite time.
You already that this is an infinite pattern: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
When Ĥ is applied to ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H simulates >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ0⟩ ⟨Ĥ1⟩ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Then these steps would keep repeating: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H0
simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H1
simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H2
simulates ⟨Ĥ3⟩ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ4⟩...
Note, the ... notation means that you >>>>>>>>>>>>>>>>>>>>>>>>>>>>> intend the pattern to >>>>>>>>>>>>>>>>>>>>>>>>>>>>> keep on
repeating for ever, so you are SHOWING 3 >>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps, but
stateing that more
occur.
What I said, was that pattern only repeats >>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinity if
embedded_H never
aborts its simulation. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
When embedded_H correctly computes the >>>>>>>>>>>>>>>>>>>>>>>>>>>> mapping from its
input finite
strings ⟨Ĥ⟩ ⟨Ĥ⟩ to its own final reject state
Which it doesn't, because Ĥ applied to ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>>>>>>>>>> halts, and that is
the behavior that embedded_H (and therefore >>>>>>>>>>>>>>>>>>>>>>>>>>> H) is stipulated
to answer about. So anything you say that >>>>>>>>>>>>>>>>>>>>>>>>>>> follows doesn't
matter.
Halting problem undecidability and infinitely >>>>>>>>>>>>>>>>>>>>>>>>>> nested
simulation (V4)
https://www.researchgate.net/publication/359349179_Halting_problem_undecidability_and_infinitely_nested_simulation_V4
I've read it, and it's bogus. It says nothing >>>>>>>>>>>>>>>>>>>>>>>>> more than what
you've been saying before.
To repeat:
When H3 correctly computes the mapping from its >>>>>>>>>>>>>>>>>>>>>>>>> input finite
strings <N> <3> to its own final reject state >>>>>>>>>>>>>>>>>>>>>>>>> on the basis that there is
no finite number N of steps of correct >>>>>>>>>>>>>>>>>>>>>>>>> simulation of this input
by the
UTM within H3 then H3 has correctly decided >>>>>>>>>>>>>>>>>>>>>>>>> that its
input never halts.
confusion with your ⟨Ĥ3⟩. I'll call it Ha3 >>>>>>>>>>>>>>>>>>>>>>> instead. So Ha3 uses
as its halt status criteria: simulate for 3 steps >>>>>>>>>>>>>>>>>>>>>>> and abort.
You might as well define counting to ten: 1,2,3 DONE. >>>>>>>>>>>>>>>>>>>>>
Ha3 applied to <N><5> reporting non-halting is >>>>>>>>>>>>>>>>>>> incorrect?
I take it that you want me to ignore everything you say. >>>>>>>>>>>>>>>>>> This work is intended to be my legacy before I die. >>>>>>>>>>>>>>>>>> If you just want to play head games go fornicate >>>>>>>>>>>>>>>>>> yourself.
The fact you have trouble with these simple questions >>>>>>>>>>>>>>>>> shows how bad your
logic is.
So in other words H3a is not simulating for enough steps? >>>>>>>>>>>>>>>
TRY AND FIND ANY ERROR IN THESE EXACT WORDS:
As long as the simulated input to embedded_H could never >>>>>>>>>>>>>> reach its final state in any finite number of steps of >>>>>>>>>>>>>> correct simulation by embedded_H then its rejection of >>>>>>>>>>>>>> this input is necessarily correct.
Like, you need to use THE ACTUAL DEFINITION OF WHAT H IS >>>>>>>>>>>>> SUPPOSED TO DO?
The error in your words is that you don't use the right
defintion of Halting,
So in other words you disagree with Linz:
computation that halts … the Turing machine will halt whenever >>>>>>>>>> it enters a final state. (Linz:1990:234)
Nope, I agree with him, and he says look at the direct
execution of the machine,
Ah so you believe that Linz does not accept that the direct
execution of Turing machine is computationally equivalent to the >>>>>>>> UTM simulation of the Turing machine description of this same
machine.
Computationally Equivalent, YES, but only by a REAL UTM.
Go back to my words and find the error. Every error that you have
found is merely an error in the inaccurate paraphrase of what I said. >>>>>>
TRY AND FIND ANY ERROR IN THESE EXACT WORDS:
As long as the simulated input to embedded_H could never reach its >>>>>> final state in any finite number of steps of correct simulation by >>>>>> embedded_H then its rejection of this input is necessarily correct. >>>>>>
embedded_H is NOT a UTM
Bzzt you lose, I did not use the term "UTM" in my exact words above.
BZZT BACK, LIAR.
I Said:
embedded_H is NOT a UTM
And I said the you are only allowed to critique my verbatim words that
have no "UTM".
Becasue you use the wrong definition of Halting. PERIOD.
On Monday, March 28, 2022 at 12:36:54 PM UTC-4, olcott wrote:
On 3/28/2022 11:31 AM, Dennis Bush wrote:
On Monday, March 28, 2022 at 9:19:24 AM UTC-4, olcott wrote:You designed Ha3 to make sure that it cuts off simulation prematurely.
On 3/28/2022 6:39 AM, Dennis Bush wrote:
On Sunday, March 27, 2022 at 11:18:07 PM UTC-4, olcott wrote:You stipulated that <N><5> only has five iterations.
On 3/27/2022 10:04 PM, Dennis Bush wrote:
On Sunday, March 27, 2022 at 10:59:01 PM UTC-4, olcott wrote:A halt decider computes the mapping of its inputs to its own accept or >>>>>> reject state on the basis of the actual behavior specified by its input. >>>>>>
On 3/27/2022 9:33 PM, Dennis Bush wrote:
On Sunday, March 27, 2022 at 10:24:33 PM UTC-4, olcott wrote: >>>>>>>>>> On 3/27/2022 9:10 PM, Dennis Bush wrote:The behavior of ⟨Ĥ⟩ ⟨Ĥ⟩ simulated outside of Ĥ must be computationally
On Sunday, March 27, 2022 at 10:04:22 PM UTC-4, olcott wrote: >>>>>>>>>>>> On 3/27/2022 8:47 PM, Dennis Bush wrote:I agree that I am only talking about embedded_H and Ha3 is not >>>>>>>>>> embedded_H. I am also not talking about H because Linz does not use H as
On Sunday, March 27, 2022 at 9:35:19 PM UTC-4, olcott wrote: >>>>>>>>>>>>>> I don't even look at it because it is merely a terrible attempt atFrederick Brooks - ACM Awards Turing Award (1999)
trying to get away with the strawman error.
In other words, you can't explain it because it demonstrates quite clearly that you're incorrect.
I have always focused on Brooks advice of eliminating inessential >>>>>>>>>>>> complexity https://en.wikipedia.org/wiki/No_Silver_Bullet >>>>>>>>>>>>
Keeping analysis down to it minimal essence makes some otherwise >>>>>>>>>>>> impossibly complex analysis feasible.
I only focus on the embedded copy of the Linz H at Ĥ.qx because this is
what Linz bases his conclusion on.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
state.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
final state.
TRY AND FIND ANY ERROR IN THESE EXACT WORDS:
As long as the simulated input to embedded_H could never reach its final
state in any finite number of steps of correct simulation by embedded_H
then its rejection of this input is necessarily correct. >>>>>>>>>>>> Halting problem undecidability and infinitely nested simulation (V4)
So you agree that Ha3 is correct reject the input <N><5>? Because if the above is true, then the same is true for H (since embedded_H is a copy of H) and therefore for any simulating halt decider, so this is also true:
the basis of his conclusion. We must stay focused on the simplest >>>>>>>>>> possible essence.
Yes you are talking about H (or more accurately Ha).
equivalent to the direct execution of Ĥ applied to ⟨Ĥ⟩ yet not the same
as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated inside of Ĥ because:
The directly executed Ĥ applied to ⟨Ĥ⟩ is the first invocation of
infinite recursion that only terminates normally because of its one-way
dependency relationship on embedded_H aborting the second invocation of
this otherwise infinite recursion.
That's a convoluted way of saying that H is unable to simulate Ĥ applied to ⟨Ĥ⟩ accurately.
embedded_H does correctly simulate ⟨Ĥ⟩ ⟨Ĥ⟩ until it sees that this
simulated input will never reach its own final state ⟨Ĥ.qn⟩.
Similarly, Ha3 does correctly simulate <N><5> until it sees that this simulated input will never reach its own final state <N>.qy. Because the simulated input never reaches its final state of <N>.qy, Ha3 is correct to reject it.
Ha3 is merely halt decider intentionally designed to get the wrong
answer. I really don't have time to spent on screwy ideas like this.
By your own logic, Ha3 is correct to reject <N><5>. The simulated input to Ha3 could never reach its final state in
any finite number of steps of correct simulation by Ha3.
If you insist on playing these head games this will be the last response
I will provide.
So in other words Ha3 is wrong because it didn't simulate long enough?
On Monday, March 28, 2022 at 5:32:35 PM UTC-4, olcott wrote:that it cannot simulate its input to its own final state in a finite number of steps. That's your test for whether a simulating halt decider is correct.
On 3/28/2022 4:05 PM, Dennis Bush wrote:
On Monday, March 28, 2022 at 4:41:13 PM UTC-4, olcott wrote:
On 3/28/2022 11:48 AM, Dennis Bush wrote:
On Monday, March 28, 2022 at 12:36:54 PM UTC-4, olcott wrote:When we ask: Is there any finite number of steps that embedded_H can
On 3/28/2022 11:31 AM, Dennis Bush wrote:
On Monday, March 28, 2022 at 9:19:24 AM UTC-4, olcott wrote:You designed Ha3 to make sure that it cuts off simulation prematurely. >>>>>> If you insist on playing these head games this will be the last response >>>>>> I will provide.
On 3/28/2022 6:39 AM, Dennis Bush wrote:By your own logic, Ha3 is correct to reject <N><5>. The simulated input to Ha3 could never reach its final state in
On Sunday, March 27, 2022 at 11:18:07 PM UTC-4, olcott wrote: >>>>>>>>>> On 3/27/2022 10:04 PM, Dennis Bush wrote:You stipulated that <N><5> only has five iterations.
Similarly, Ha3 does correctly simulate <N><5> until it sees that this simulated input will never reach its own final state <N>.qy. Because the simulated input never reaches its final state of <N>.qy, Ha3 is correct to reject it.On Sunday, March 27, 2022 at 10:59:01 PM UTC-4, olcott wrote: >>>>>>>>>>>> On 3/27/2022 9:33 PM, Dennis Bush wrote:A halt decider computes the mapping of its inputs to its own accept or
On Sunday, March 27, 2022 at 10:24:33 PM UTC-4, olcott wrote: >>>>>>>>>>>>>> On 3/27/2022 9:10 PM, Dennis Bush wrote:The behavior of ⟨Ĥ⟩ ⟨Ĥ⟩ simulated outside of Ĥ must be computationally
On Sunday, March 27, 2022 at 10:04:22 PM UTC-4, olcott wrote: >>>>>>>>>>>>>>>> On 3/27/2022 8:47 PM, Dennis Bush wrote:I agree that I am only talking about embedded_H and Ha3 is not >>>>>>>>>>>>>> embedded_H. I am also not talking about H because Linz does not use H as
On Sunday, March 27, 2022 at 9:35:19 PM UTC-4, olcott wrote: >>>>>>>>>>>>>>>>>> I don't even look at it because it is merely a terrible attempt atFrederick Brooks - ACM Awards Turing Award (1999) >>>>>>>>>>>>>>>> I have always focused on Brooks advice of eliminating inessential
trying to get away with the strawman error. >>>>>>>>>>>>>>>>>In other words, you can't explain it because it demonstrates quite clearly that you're incorrect.
complexity https://en.wikipedia.org/wiki/No_Silver_Bullet >>>>>>>>>>>>>>>>
Keeping analysis down to it minimal essence makes some otherwise
impossibly complex analysis feasible.
I only focus on the embedded copy of the Linz H at Ĥ.qx because this is
what Linz bases his conclusion on.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
state.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
final state.
TRY AND FIND ANY ERROR IN THESE EXACT WORDS:
As long as the simulated input to embedded_H could never reach its final
state in any finite number of steps of correct simulation by embedded_H
then its rejection of this input is necessarily correct. >>>>>>>>>>>>>>>> Halting problem undecidability and infinitely nested simulation (V4)
So you agree that Ha3 is correct reject the input <N><5>? Because if the above is true, then the same is true for H (since embedded_H is a copy of H) and therefore for any simulating halt decider, so this is also true:
the basis of his conclusion. We must stay focused on the simplest
possible essence.
Yes you are talking about H (or more accurately Ha).
equivalent to the direct execution of Ĥ applied to ⟨Ĥ⟩ yet not the same
as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated inside of Ĥ because:
The directly executed Ĥ applied to ⟨Ĥ⟩ is the first invocation of
infinite recursion that only terminates normally because of its one-way
dependency relationship on embedded_H aborting the second invocation of
this otherwise infinite recursion.
That's a convoluted way of saying that H is unable to simulate Ĥ applied to ⟨Ĥ⟩ accurately.
reject state on the basis of the actual behavior specified by its input.
embedded_H does correctly simulate ⟨Ĥ⟩ ⟨Ĥ⟩ until it sees that this
simulated input will never reach its own final state ⟨Ĥ.qn⟩. >>>>>>>>>
Ha3 is merely halt decider intentionally designed to get the wrong >>>>>>>> answer. I really don't have time to spent on screwy ideas like this. >>>>>>>
any finite number of steps of correct simulation by Ha3.
So in other words Ha3 is wrong because it didn't simulate long enough? >>>>>
correctly simulate its input ⟨Ĥ⟩ ⟨Ĥ⟩ such that this input reaches its
own final state? An answer of: "no" means that embedded_H can correctly >>>> reject its input.
Changing the question to any other variation such as Ha3 applied to
<N><5> is merely the deceitful attempt of trying to get away with the
strawman error.
It is not deceitful. It's a test of your logic. You say that the criteria for determining if Ha (because embedded_H is embedded_Ha if it aborts, and Ha is the same as embedded_Ha if it was built properly) applied to <Ha^><Ha^> is correct to reject is
So by that same logic, since Ha3 cannot simulate its input <N><5> to its own final state in any finite number of steps, it is correct to reject it.
correctly simulate its input ⟨Ĥ⟩ ⟨Ĥ⟩
does not include incorrectly cutting off the simulation.
In that case, because Hb applied to <Ha^><Ha^> accepts its input, Ha applied to <Ha^><Ha^> incorrectly cuts off the simulation.
--
Copyright 2022 Pete Olcott
"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer
On Monday, March 28, 2022 at 6:12:09 PM UTC-4, olcott wrote:reject is that it cannot simulate its input to its own final state in a finite number of steps. That's your test for whether a simulating halt decider is correct.
On 3/28/2022 5:07 PM, Dennis Bush wrote:
On Monday, March 28, 2022 at 6:01:26 PM UTC-4, olcott wrote:
On 3/28/2022 4:44 PM, Dennis Bush wrote:
On Monday, March 28, 2022 at 5:32:35 PM UTC-4, olcott wrote:
On 3/28/2022 4:05 PM, Dennis Bush wrote:
On Monday, March 28, 2022 at 4:41:13 PM UTC-4, olcott wrote:
On 3/28/2022 11:48 AM, Dennis Bush wrote:
On Monday, March 28, 2022 at 12:36:54 PM UTC-4, olcott wrote: >>>>>>>>>> On 3/28/2022 11:31 AM, Dennis Bush wrote:When we ask: Is there any finite number of steps that embedded_H can >>>>>>>> correctly simulate its input ⟨Ĥ⟩ ⟨Ĥ⟩ such that this input reaches its
On Monday, March 28, 2022 at 9:19:24 AM UTC-4, olcott wrote: >>>>>>>>>>>> On 3/28/2022 6:39 AM, Dennis Bush wrote:You designed Ha3 to make sure that it cuts off simulation prematurely.
On Sunday, March 27, 2022 at 11:18:07 PM UTC-4, olcott wrote: >>>>>>>>>>>>>> On 3/27/2022 10:04 PM, Dennis Bush wrote:You stipulated that <N><5> only has five iterations.
On Sunday, March 27, 2022 at 10:59:01 PM UTC-4, olcott wrote: >>>>>>>>>>>>>>>> On 3/27/2022 9:33 PM, Dennis Bush wrote:A halt decider computes the mapping of its inputs to its own accept or
On Sunday, March 27, 2022 at 10:24:33 PM UTC-4, olcott wrote: >>>>>>>>>>>>>>>>>> On 3/27/2022 9:10 PM, Dennis Bush wrote:equivalent to the direct execution of Ĥ applied to ⟨Ĥ⟩ yet not the same
On Sunday, March 27, 2022 at 10:04:22 PM UTC-4, olcott wrote:I agree that I am only talking about embedded_H and Ha3 is not
On 3/27/2022 8:47 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 9:35:19 PM UTC-4, olcott wrote:
Frederick Brooks - ACM Awards Turing Award (1999) >>>>>>>>>>>>>>>>>>>> I have always focused on Brooks advice of eliminating inessentialI don't even look at it because it is merely a terrible attempt atIn other words, you can't explain it because it demonstrates quite clearly that you're incorrect.
trying to get away with the strawman error. >>>>>>>>>>>>>>>>>>>>>
complexity https://en.wikipedia.org/wiki/No_Silver_Bullet >>>>>>>>>>>>>>>>>>>>
Keeping analysis down to it minimal essence makes some otherwise
impossibly complex analysis feasible.
I only focus on the embedded copy of the Linz H at Ĥ.qx because this is
what Linz bases his conclusion on.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ >>>>>>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
state.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>>>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
final state.
TRY AND FIND ANY ERROR IN THESE EXACT WORDS: >>>>>>>>>>>>>>>>>>>> As long as the simulated input to embedded_H could never reach its final
state in any finite number of steps of correct simulation by embedded_H
then its rejection of this input is necessarily correct. >>>>>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely nested simulation (V4)
So you agree that Ha3 is correct reject the input <N><5>? Because if the above is true, then the same is true for H (since embedded_H is a copy of H) and therefore for any simulating halt decider, so this is also true:
embedded_H. I am also not talking about H because Linz does not use H as
the basis of his conclusion. We must stay focused on the simplest
possible essence.
Yes you are talking about H (or more accurately Ha). >>>>>>>>>>>>>>>> The behavior of ⟨Ĥ⟩ ⟨Ĥ⟩ simulated outside of Ĥ must be computationally
as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated inside of Ĥ because: >>>>>>>>>>>>>>
The directly executed Ĥ applied to ⟨Ĥ⟩ is the first invocation of
infinite recursion that only terminates normally because of its one-way
dependency relationship on embedded_H aborting the second invocation of
this otherwise infinite recursion.
That's a convoluted way of saying that H is unable to simulate Ĥ applied to ⟨Ĥ⟩ accurately.
reject state on the basis of the actual behavior specified by its input.
embedded_H does correctly simulate ⟨Ĥ⟩ ⟨Ĥ⟩ until it sees that this
simulated input will never reach its own final state ⟨Ĥ.qn⟩.
Similarly, Ha3 does correctly simulate <N><5> until it sees that this simulated input will never reach its own final state <N>.qy. Because the simulated input never reaches its final state of <N>.qy, Ha3 is correct to reject it.
Ha3 is merely halt decider intentionally designed to get the wrong >>>>>>>>>>>> answer. I really don't have time to spent on screwy ideas like this.
By your own logic, Ha3 is correct to reject <N><5>. The simulated input to Ha3 could never reach its final state in
any finite number of steps of correct simulation by Ha3.
If you insist on playing these head games this will be the last response
I will provide.
So in other words Ha3 is wrong because it didn't simulate long enough?
own final state? An answer of: "no" means that embedded_H can correctly
reject its input.
Changing the question to any other variation such as Ha3 applied to >>>>>>>> <N><5> is merely the deceitful attempt of trying to get away with the >>>>>>>> strawman error.
It is not deceitful. It's a test of your logic. You say that the criteria for determining if Ha (because embedded_H is embedded_Ha if it aborts, and Ha is the same as embedded_Ha if it was built properly) applied to <Ha^><Ha^> is correct to
My proof has not been invalidated your strawman error.This is why I disallow changing the subject away from the copy of Linz H >>>> embedded in Linz Ĥ. There is an infinite set of permutations of
So by that same logic, since Ha3 cannot simulate its input <N><5> to its own final state in any finite number of steps, it is correct to reject it.
correctly simulate its input ⟨Ĥ⟩ ⟨Ĥ⟩
does not include incorrectly cutting off the simulation.
In that case, because Hb applied to <Ha^><Ha^> accepts its input, Ha applied to <Ha^><Ha^> incorrectly cuts off the simulation.
embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ that are incorrect. We could keep talking
in circles endlessly forever preventing closure if I tolerated these
deceitful attempts of the strawman error.
So in other words, you can't explain away Hb applied to <Ha^><Ha^> reporting halting as correct, so you try to change the subject. Since you can't refute it, that mean Linz is validated. Q.E.D.
So what are you doing to do with yourself now that your proof has been invalidated?
The only reason why you derive these strawman errors is that there are
no errors in my exact words and you know it.
If Hb accepting <Ha^><Ha^> is directly counter to your desired result. If it is wrong you would be able to explain why. Your failure to do so is an admission that your reasoning gives incorrect results and that you have no case.
This all stems from the fact that your H is not correctly answering the question of whether H^ applied to <H^> halts as required by the proof. Don't tell us how many dogs are in your living room when we ask how many cats are in your kitchen.
Peter Olcott wrote:
On 3/28/2022 7:15 PM, Richard Damon wrote:...
No, people rebuttals are pointing out a TRUTH to you.
Your problem is you have confused yourself by accepting a FALSE
premise. Your 'Test' for Halting is NOT a valid test.
FAIL.
All you have is dogma, you have no correct reasoning as a rebuttal.
Not at all, he has arguments.
On Monday, March 28, 2022 at 9:05:23 PM UTC-4, olcott wrote:reject is that it cannot simulate its input to its own final state in a finite number of steps. That's your test for whether a simulating halt decider is correct.
On 3/28/2022 7:33 PM, Dennis Bush wrote:
On Monday, March 28, 2022 at 6:12:09 PM UTC-4, olcott wrote:
On 3/28/2022 5:07 PM, Dennis Bush wrote:
On Monday, March 28, 2022 at 6:01:26 PM UTC-4, olcott wrote:
On 3/28/2022 4:44 PM, Dennis Bush wrote:
On Monday, March 28, 2022 at 5:32:35 PM UTC-4, olcott wrote:
On 3/28/2022 4:05 PM, Dennis Bush wrote:
On Monday, March 28, 2022 at 4:41:13 PM UTC-4, olcott wrote: >>>>>>>>>> On 3/28/2022 11:48 AM, Dennis Bush wrote:
On Monday, March 28, 2022 at 12:36:54 PM UTC-4, olcott wrote: >>>>>>>>>>>> On 3/28/2022 11:31 AM, Dennis Bush wrote:When we ask: Is there any finite number of steps that embedded_H can >>>>>>>>>> correctly simulate its input ⟨Ĥ⟩ ⟨Ĥ⟩ such that this input reaches its
On Monday, March 28, 2022 at 9:19:24 AM UTC-4, olcott wrote: >>>>>>>>>>>>>> On 3/28/2022 6:39 AM, Dennis Bush wrote:If you insist on playing these head games this will be the last response
On Sunday, March 27, 2022 at 11:18:07 PM UTC-4, olcott wrote: >>>>>>>>>>>>>>>> On 3/27/2022 10:04 PM, Dennis Bush wrote:You stipulated that <N><5> only has five iterations. >>>>>>>>>>>>>> Ha3 is merely halt decider intentionally designed to get the wrong
On Sunday, March 27, 2022 at 10:59:01 PM UTC-4, olcott wrote: >>>>>>>>>>>>>>>>>> On 3/27/2022 9:33 PM, Dennis Bush wrote:A halt decider computes the mapping of its inputs to its own accept or
On Sunday, March 27, 2022 at 10:24:33 PM UTC-4, olcott wrote:equivalent to the direct execution of Ĥ applied to ⟨Ĥ⟩ yet not the same
On 3/27/2022 9:10 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 10:04:22 PM UTC-4, olcott wrote:
I agree that I am only talking about embedded_H and Ha3 is notOn 3/27/2022 8:47 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 9:35:19 PM UTC-4, olcott wrote:
Frederick Brooks - ACM Awards Turing Award (1999) >>>>>>>>>>>>>>>>>>>>>> I have always focused on Brooks advice of eliminating inessentialI don't even look at it because it is merely a terrible attempt atIn other words, you can't explain it because it demonstrates quite clearly that you're incorrect.
trying to get away with the strawman error. >>>>>>>>>>>>>>>>>>>>>>>
complexity https://en.wikipedia.org/wiki/No_Silver_Bullet
Keeping analysis down to it minimal essence makes some otherwise
impossibly complex analysis feasible. >>>>>>>>>>>>>>>>>>>>>>
I only focus on the embedded copy of the Linz H at Ĥ.qx because this is
what Linz bases his conclusion on. >>>>>>>>>>>>>>>>>>>>>>
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
state.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>>>>>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
final state.
TRY AND FIND ANY ERROR IN THESE EXACT WORDS: >>>>>>>>>>>>>>>>>>>>>> As long as the simulated input to embedded_H could never reach its final
state in any finite number of steps of correct simulation by embedded_H
then its rejection of this input is necessarily correct. >>>>>>>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely nested simulation (V4)
So you agree that Ha3 is correct reject the input <N><5>? Because if the above is true, then the same is true for H (since embedded_H is a copy of H) and therefore for any simulating halt decider, so this is also true:
embedded_H. I am also not talking about H because Linz does not use H as
the basis of his conclusion. We must stay focused on the simplest
possible essence.
Yes you are talking about H (or more accurately Ha). >>>>>>>>>>>>>>>>>> The behavior of ⟨Ĥ⟩ ⟨Ĥ⟩ simulated outside of Ĥ must be computationally
as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated inside of Ĥ because: >>>>>>>>>>>>>>>>
The directly executed Ĥ applied to ⟨Ĥ⟩ is the first invocation of
infinite recursion that only terminates normally because of its one-way
dependency relationship on embedded_H aborting the second invocation of
this otherwise infinite recursion.
That's a convoluted way of saying that H is unable to simulate Ĥ applied to ⟨Ĥ⟩ accurately.
reject state on the basis of the actual behavior specified by its input.
embedded_H does correctly simulate ⟨Ĥ⟩ ⟨Ĥ⟩ until it sees that this
simulated input will never reach its own final state ⟨Ĥ.qn⟩.
Similarly, Ha3 does correctly simulate <N><5> until it sees that this simulated input will never reach its own final state <N>.qy. Because the simulated input never reaches its final state of <N>.qy, Ha3 is correct to reject it.
answer. I really don't have time to spent on screwy ideas like this.
By your own logic, Ha3 is correct to reject <N><5>. The simulated input to Ha3 could never reach its final state in
any finite number of steps of correct simulation by Ha3. >>>>>>>>>>>> You designed Ha3 to make sure that it cuts off simulation prematurely.
I will provide.
So in other words Ha3 is wrong because it didn't simulate long enough?
own final state? An answer of: "no" means that embedded_H can correctly
reject its input.
Changing the question to any other variation such as Ha3 applied to >>>>>>>>>> <N><5> is merely the deceitful attempt of trying to get away with the
strawman error.
It is not deceitful. It's a test of your logic. You say that the criteria for determining if Ha (because embedded_H is embedded_Ha if it aborts, and Ha is the same as embedded_Ha if it was built properly) applied to <Ha^><Ha^> is correct to
Not at all. (Linz got this wrong too) There is never a case where anyMy proof has not been invalidated your strawman error.This is why I disallow changing the subject away from the copy of Linz H >>>>>> embedded in Linz Ĥ. There is an infinite set of permutations of
So by that same logic, since Ha3 cannot simulate its input <N><5> to its own final state in any finite number of steps, it is correct to reject it.
correctly simulate its input ⟨Ĥ⟩ ⟨Ĥ⟩
does not include incorrectly cutting off the simulation.
In that case, because Hb applied to <Ha^><Ha^> accepts its input, Ha applied to <Ha^><Ha^> incorrectly cuts off the simulation.
embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ that are incorrect. We could keep talking
in circles endlessly forever preventing closure if I tolerated these >>>>>> deceitful attempts of the strawman error.
So in other words, you can't explain away Hb applied to <Ha^><Ha^> reporting halting as correct, so you try to change the subject. Since you can't refute it, that mean Linz is validated. Q.E.D.
So what are you doing to do with yourself now that your proof has been invalidated?
The only reason why you derive these strawman errors is that there are >>>> no errors in my exact words and you know it.
If Hb accepting <Ha^><Ha^> is directly counter to your desired result. If it is wrong you would be able to explain why. Your failure to do so is an admission that your reasoning gives incorrect results and that you have no case.
This all stems from the fact that your H is not correctly answering the question of whether H^ applied to <H^> halts as required by the proof. Don't tell us how many dogs are in your living room when we ask how many cats are in your kitchen.
decider gives a rat's ass about the computation that contains itself.
There is no confusion. The definition is what it is. It is perfectly acceptable for H to take <H> <<H^><H^>> as an input.
A halt decider (because it is a decider) must report on the behavior
specified by its finite string input. As long as it correctly does that
then nothing else can possibly matter.
And the behavior specified by <H^><H^> is *by definition* H^ applied to <H^>.
On 3/28/2022 10:38 PM, Dennis Bush wrote:
On Monday, March 28, 2022 at 11:30:14 PM UTC-4, olcott wrote:
On 3/28/2022 10:10 PM, Dennis Bush wrote:
On Monday, March 28, 2022 at 10:45:03 PM UTC-4, olcott wrote:I am not going to dredge through your change of notational conventions I >>> have chemotherapy all day tomorrow.
On 3/28/2022 8:30 PM, Dennis Bush wrote:
On Monday, March 28, 2022 at 9:05:23 PM UTC-4, olcott wrote:Except that it is not. The behavior of a correct simulation of a
On 3/28/2022 7:33 PM, Dennis Bush wrote:
On Monday, March 28, 2022 at 6:12:09 PM UTC-4, olcott wrote:Not at all. (Linz got this wrong too) There is never a case where >>>>>>> any
On 3/28/2022 5:07 PM, Dennis Bush wrote:
On Monday, March 28, 2022 at 6:01:26 PM UTC-4, olcott wrote: >>>>>>>>>>> On 3/28/2022 4:44 PM, Dennis Bush wrote:My proof has not been invalidated your strawman error.
On Monday, March 28, 2022 at 5:32:35 PM UTC-4, olcott wrote: >>>>>>>>>>>>> On 3/28/2022 4:05 PM, Dennis Bush wrote:This is why I disallow changing the subject away from the >>>>>>>>>>> copy of Linz H
In that case, because Hb applied to <Ha^><Ha^> accepts its >>>>>>>>>>>> input, Ha applied to <Ha^><Ha^> incorrectly cuts off the >>>>>>>>>>>> simulation.On Monday, March 28, 2022 at 4:41:13 PM UTC-4, olcott wrote: >>>>>>>>>>>>>>> On 3/28/2022 11:48 AM, Dennis Bush wrote:
On Monday, March 28, 2022 at 12:36:54 PM UTC-4, olcott >>>>>>>>>>>>>>>> wrote:When we ask: Is there any finite number of steps that >>>>>>>>>>>>>>> embedded_H can
On 3/28/2022 11:31 AM, Dennis Bush wrote:
On Monday, March 28, 2022 at 9:19:24 AM UTC-4, olcott >>>>>>>>>>>>>>>>>> wrote:If you insist on playing these head games this will be >>>>>>>>>>>>>>>>> the last response
On 3/28/2022 6:39 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 11:18:07 PM UTC-4, >>>>>>>>>>>>>>>>>>>> olcott wrote:
You stipulated that <N><5> only has five iterations. >>>>>>>>>>>>>>>>>>> Ha3 is merely halt decider intentionally designed to >>>>>>>>>>>>>>>>>>> get the wrongOn 3/27/2022 10:04 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 10:59:01 PM UTC-4, >>>>>>>>>>>>>>>>>>>>>> olcott wrote:
reject state on the basis of the actual behavior >>>>>>>>>>>>>>>>>>>>> specified by its input.On 3/27/2022 9:33 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 10:24:33 PM UTC-4, >>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:That's a convoluted way of saying that H is unable >>>>>>>>>>>>>>>>>>>>>> to simulate Ĥ applied to ⟨Ĥ⟩ accurately. >>>>>>>>>>>>>>>>>>>>> A halt decider computes the mapping of its inputs >>>>>>>>>>>>>>>>>>>>> to its own accept or
The behavior of ⟨Ĥ⟩ ⟨Ĥ⟩ simulated outside of ĤOn 3/27/2022 9:10 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 10:04:22 PM >>>>>>>>>>>>>>>>>>>>>>>>>> UTC-4, olcott wrote:
I agree that I am only talking about embedded_H >>>>>>>>>>>>>>>>>>>>>>>>> and Ha3 is notOn 3/27/2022 8:47 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On Sunday, March 27, 2022 at 9:35:19 PM >>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC-4, olcott wrote:
Frederick Brooks - ACM Awards Turing Award >>>>>>>>>>>>>>>>>>>>>>>>>>> (1999)I don't even look at it because it is >>>>>>>>>>>>>>>>>>>>>>>>>>>>> merely a terrible attempt at >>>>>>>>>>>>>>>>>>>>>>>>>>>>> trying to get away with the strawman error. >>>>>>>>>>>>>>>>>>>>>>>>>>>>In other words, you can't explain it because >>>>>>>>>>>>>>>>>>>>>>>>>>>> it demonstrates quite clearly that you're >>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect.
I have always focused on Brooks advice of >>>>>>>>>>>>>>>>>>>>>>>>>>> eliminating inessential
complexity
https://en.wikipedia.org/wiki/No_Silver_Bullet >>>>>>>>>>>>>>>>>>>>>>>>>>>
Keeping analysis down to it minimal essence >>>>>>>>>>>>>>>>>>>>>>>>>>> makes some otherwise
impossibly complex analysis feasible. >>>>>>>>>>>>>>>>>>>>>>>>>>>
I only focus on the embedded copy of the Linz >>>>>>>>>>>>>>>>>>>>>>>>>>> H at Ĥ.qx because this is >>>>>>>>>>>>>>>>>>>>>>>>>>> what Linz bases his conclusion on. >>>>>>>>>>>>>>>>>>>>>>>>>>>
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by >>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H would reach its final >>>>>>>>>>>>>>>>>>>>>>>>>>> state.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by >>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H would never reach its >>>>>>>>>>>>>>>>>>>>>>>>>>> final state.
TRY AND FIND ANY ERROR IN THESE EXACT WORDS: >>>>>>>>>>>>>>>>>>>>>>>>>>> As long as the simulated input to embedded_H >>>>>>>>>>>>>>>>>>>>>>>>>>> could never reach its final >>>>>>>>>>>>>>>>>>>>>>>>>>> state in any finite number of steps of >>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation by embedded_H >>>>>>>>>>>>>>>>>>>>>>>>>>> then its rejection of this input is >>>>>>>>>>>>>>>>>>>>>>>>>>> necessarily correct.
Halting problem undecidability and infinitely >>>>>>>>>>>>>>>>>>>>>>>>>>> nested simulation (V4)
So you agree that Ha3 is correct reject the >>>>>>>>>>>>>>>>>>>>>>>>>> input <N><5>? Because if the above is true, >>>>>>>>>>>>>>>>>>>>>>>>>> then the same is true for H (since embedded_H >>>>>>>>>>>>>>>>>>>>>>>>>> is a copy of H) and therefore for any >>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider, so this is also true: >>>>>>>>>>>>>>>>>>>>>>>>>>
embedded_H. I am also not talking about H >>>>>>>>>>>>>>>>>>>>>>>>> because Linz does not use H as >>>>>>>>>>>>>>>>>>>>>>>>> the basis of his conclusion. We must stay >>>>>>>>>>>>>>>>>>>>>>>>> focused on the simplest
possible essence.
Yes you are talking about H (or more accurately >>>>>>>>>>>>>>>>>>>>>>>> Ha).
must be computationally
equivalent to the direct execution of Ĥ applied >>>>>>>>>>>>>>>>>>>>>>> to ⟨Ĥ⟩ yet not the same
as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated inside of Ĥ because: >>>>>>>>>>>>>>>>>>>>>
The directly executed Ĥ applied to ⟨Ĥ⟩ is the >>>>>>>>>>>>>>>>>>>>>>> first invocation of
infinite recursion that only terminates normally >>>>>>>>>>>>>>>>>>>>>>> because of its one-way
dependency relationship on embedded_H aborting >>>>>>>>>>>>>>>>>>>>>>> the second invocation of
this otherwise infinite recursion. >>>>>>>>>>>>>>>>>>>>>>
embedded_H does correctly simulate ⟨Ĥ⟩ ⟨Ĥ⟩ until it
sees that this
simulated input will never reach its own final >>>>>>>>>>>>>>>>>>>>> state ⟨Ĥ.qn⟩.
Similarly, Ha3 does correctly simulate <N><5> until >>>>>>>>>>>>>>>>>>>> it sees that this simulated input will never reach >>>>>>>>>>>>>>>>>>>> its own final state <N>.qy. Because the simulated >>>>>>>>>>>>>>>>>>>> input never reaches its final state of <N>.qy, Ha3 >>>>>>>>>>>>>>>>>>>> is correct to reject it.
answer. I really don't have time to spent on screwy >>>>>>>>>>>>>>>>>>> ideas like this.
By your own logic, Ha3 is correct to reject <N><5>. >>>>>>>>>>>>>>>>>> The simulated input to Ha3 could never reach its final >>>>>>>>>>>>>>>>>> state in
any finite number of steps of correct simulation by Ha3. >>>>>>>>>>>>>>>>> You designed Ha3 to make sure that it cuts off >>>>>>>>>>>>>>>>> simulation prematurely.
I will provide.
So in other words Ha3 is wrong because it didn't >>>>>>>>>>>>>>>> simulate long enough?
correctly simulate its input ⟨Ĥ⟩ ⟨Ĥ⟩ such that this input
reaches its
own final state? An answer of: "no" means that embedded_H >>>>>>>>>>>>>>> can correctly
reject its input.
Changing the question to any other variation such as Ha3 >>>>>>>>>>>>>>> applied to
<N><5> is merely the deceitful attempt of trying to get >>>>>>>>>>>>>>> away with the
strawman error.
It is not deceitful. It's a test of your logic. You say >>>>>>>>>>>>>> that the criteria for determining if Ha (because
embedded_H is embedded_Ha if it aborts, and Ha is the same >>>>>>>>>>>>>> as embedded_Ha if it was built properly) applied to >>>>>>>>>>>>>> <Ha^><Ha^> is correct to reject is that it cannot simulate >>>>>>>>>>>>>> its input to its own final state in a finite number of >>>>>>>>>>>>>> steps. That's your test for whether a simulating halt >>>>>>>>>>>>>> decider is correct.
So by that same logic, since Ha3 cannot simulate its input >>>>>>>>>>>>>> <N><5> to its own final state in any finite number of >>>>>>>>>>>>>> steps, it is correct to reject it.
correctly simulate its input ⟨Ĥ⟩ ⟨Ĥ⟩
does not include incorrectly cutting off the simulation. >>>>>>>>>>>>
embedded in Linz Ĥ. There is an infinite set of permutations of >>>>>>>>>>> embedded_H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ that are incorrect. We could
keep talking
in circles endlessly forever preventing closure if I
tolerated these
deceitful attempts of the strawman error.
So in other words, you can't explain away Hb applied to
<Ha^><Ha^> reporting halting as correct, so you try to change >>>>>>>>>> the subject. Since you can't refute it, that mean Linz is
validated. Q.E.D.
So what are you doing to do with yourself now that your proof >>>>>>>>>> has been invalidated?
The only reason why you derive these strawman errors is that >>>>>>>>> there are
no errors in my exact words and you know it.
If Hb accepting <Ha^><Ha^> is directly counter to your desired >>>>>>>> result. If it is wrong you would be able to explain why. Your
failure to do so is an admission that your reasoning gives
incorrect results and that you have no case.
This all stems from the fact that your H is not correctly
answering the question of whether H^ applied to <H^> halts as
required by the proof. Don't tell us how many dogs are in your >>>>>>>> living room when we ask how many cats are in your kitchen.
decider gives a rat's ass about the computation that contains
itself.
There is no confusion. The definition is what it is. It is
perfectly acceptable for H to take <H> <<H^><H^>> as an input.
A halt decider (because it is a decider) must report on the behavior >>>>>>> specified by its finite string input. As long as it correctly
does that
then nothing else can possibly matter.
And the behavior specified by <H^><H^> is *by definition* H^
applied to <H^>.
Turing
machine description is the ULTIMATE measure of the behavior that it
specifies:
When Ĥ is applied to ⟨Ĥ⟩
Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
Then these steps would keep repeating:
Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩
⟨Ĥ4⟩...
Unless and until embedded_H aborts its simulation, then every nested >>>>> simulation immediately stops with none these simulated inputs ever
reaching their own final state of ⟨Ĥ.qn⟩ (thus halting).
Let me fix that for you:
When Ĥn is applied to ⟨Ĥn⟩
I merely changed all references to H and H^ to Hn and Hn^ since that's
the only case with infinite recursion. To reiterate:
I probably won't be anble to look at it. I only have two more minutes I
can spend on this until 6:00 PM tomorrow.
When Ĥn is applied to ⟨Ĥn⟩
Ĥn copies its input ⟨Ĥn0⟩ to ⟨Ĥn1⟩ then embedded_Hn simulates ⟨Ĥn0⟩ ⟨Ĥn1⟩
Then these steps would keep repeating:
Ĥn0 copies its input ⟨Ĥn1⟩ to ⟨Ĥn2⟩ then embedded_Hn0 simulates ⟨Ĥn1⟩
⟨Ĥn2⟩
Ĥn1 copies its input ⟨Ĥn2⟩ to ⟨Ĥn3⟩ then embedded_Hn1 simulates ⟨Ĥn2⟩
⟨Ĥn3⟩
Ĥn2 copies its input ⟨Ĥn3⟩ to ⟨Ĥn4⟩ then embedded_Hn2 simulates ⟨Ĥn3⟩
⟨Ĥn4⟩...
Unless and until embedded_Hn aborts its simulation, then every nested
simulation immediately stops with none these simulated inputs ever
reaching their own final state of ⟨Ĥn.qn⟩ (thus halting).
So embedded_Hn, and equivalently Hn, would be correct to report
non-halting. But Hn doesn't abort, so it can't.
When Ĥa is applied to ⟨Ĥa⟩
Ĥa copies its input ⟨Ĥa0⟩ to ⟨Ĥa1⟩ then embedded_Ha simulates ⟨Ĥa0⟩ ⟨Ĥa1⟩
embedded_Ha sees what it believes to be an infinite behavior pattern,
aborts its simulation, and reports non-halting.
Ĥa goes to state Ĥa.qn and halts
--
Copyright 2022 Pete Olcott
"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer
On 3/29/22 8:33 AM, olcott wrote:
Talking about H ⟨Ĥ⟩ ⟨Ĥ⟩ diverges from the Linz proof thus is off topic.
The only way that discussing the behavior of H <H^> <H^> woud b e off
topic is if embedded_H isn't a copy of this H.
That means that you aren't actually talking about the Linz Proof.
THANK YOU for your confession.
The Linz proof only examines Ĥ applied to ⟨Ĥ⟩ thus embedded_H applied >> to ⟨Ĥ⟩ ⟨Ĥ⟩.
FLAT OUT LIE.
On Tuesday, March 29, 2022 at 11:33:05 PM UTC-4, olcott wrote:It is self evidently that the simulated input to embedded_H cannot
On 3/29/2022 7:45 AM, Dennis Bush wrote:
On Tuesday, March 29, 2022 at 8:33:15 AM UTC-4, olcott wrote:The key problem with this is that it is incorrectly assumed that ⟨Ĥ⟩ ⟨Ĥ⟩
The Linz proof only examines Ĥ applied to ⟨Ĥ⟩ thus embedded_H applied to
⟨Ĥ⟩ ⟨Ĥ⟩.
simulated outside of Ĥ must have the same behavior as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated
inside of Ĥ even after it is conclusively proved that they have
distinctly different behavior
And by "distinctly different behavior" you mean "embedded_H simulated Ĥ applied to ⟨Ĥ⟩ incorrectly",
On Tuesday, March 29, 2022 at 8:33:15 AM UTC-4, olcott wrote:
The Linz proof only examines Ĥ applied to ⟨Ĥ⟩ thus embedded_H applied to
⟨Ĥ⟩ ⟨Ĥ⟩.
On Wednesday, March 30, 2022 at 12:02:48 AM UTC-4, olcott wrote:
On 3/29/2022 10:52 PM, Dennis Bush wrote:
On Tuesday, March 29, 2022 at 11:33:05 PM UTC-4, olcott wrote:It is self evidently that the simulated input to embedded_H cannot
On 3/29/2022 7:45 AM, Dennis Bush wrote:
On Tuesday, March 29, 2022 at 8:33:15 AM UTC-4, olcott wrote:The key problem with this is that it is incorrectly assumed that ⟨Ĥ⟩ ⟨Ĥ⟩
The Linz proof only examines Ĥ applied to ⟨Ĥ⟩ thus embedded_H applied to
⟨Ĥ⟩ ⟨Ĥ⟩.
simulated outside of Ĥ must have the same behavior as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated
inside of Ĥ even after it is conclusively proved that they have
distinctly different behavior
And by "distinctly different behavior" you mean "embedded_H simulated Ĥ applied to ⟨Ĥ⟩ incorrectly",
possibly reach its own final state of ⟨Ĥ.qn⟩ in any finite number of
steps of correct simulation by embedded_H and you know it.
And by the same logic, It is self evidentl that the simulated input <N><5> to H3a cannot possibly reach its own final state of <N.qy> in any finite number of steps of correct simulation by H3a and you know it.
So if you believe that embedded_H is correct to reject ⟨Ĥ⟩⟨Ĥ⟩, you *must* also believe that H3a is correct to reject <N><5>.
--
Copyright 2022 Pete Olcott
"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer
On Wednesday, March 30, 2022 at 8:59:34 AM UTC-4, olcott wrote:
On 3/30/2022 7:06 AM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 12:02:48 AM UTC-4, olcott wrote:All that you are saying is that a halt determiner that was intentionally
On 3/29/2022 10:52 PM, Dennis Bush wrote:
On Tuesday, March 29, 2022 at 11:33:05 PM UTC-4, olcott wrote:It is self evidently that the simulated input to embedded_H cannot
On 3/29/2022 7:45 AM, Dennis Bush wrote:
On Tuesday, March 29, 2022 at 8:33:15 AM UTC-4, olcott wrote:The key problem with this is that it is incorrectly assumed that ⟨Ĥ⟩ ⟨Ĥ⟩
The Linz proof only examines Ĥ applied to ⟨Ĥ⟩ thus embedded_H applied to
⟨Ĥ⟩ ⟨Ĥ⟩.
simulated outside of Ĥ must have the same behavior as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated
inside of Ĥ even after it is conclusively proved that they have
distinctly different behavior
And by "distinctly different behavior" you mean "embedded_H simulated Ĥ applied to ⟨Ĥ⟩ incorrectly",
possibly reach its own final state of ⟨Ĥ.qn⟩ in any finite number of >>>> steps of correct simulation by embedded_H and you know it.
And by the same logic, It is self evidentl that the simulated input <N><5> to H3a cannot possibly reach its own final state of <N.qy> in any finite number of steps of correct simulation by H3a and you know it.
designed to get the wrong answer does get the wrong answer. It is not
any rebuttal of my words at all and you know it.
H3a can correctly determine that <Infinite_Loop><> is non-halting, correct? So it's just a matter of determining how to find it it gets the right answer.
I will change my words so that your spec meets these changed words:
It is self evidently correct that the simulated input to h3a cannot
possibly reach its own final state of ⟨N.qy⟩ in any insufficient number >> number of steps of correct simulation by H3a.
My specs says 1.. ∞ steps your spec says 1 .. 3 steps
embedded_Ha doesn't simulate <Ha^><Ha^> for infinite steps either. It simulates for up to some n number of steps.
On 3/29/22 11:32 PM, olcott wrote:
On 3/29/2022 7:45 AM, Dennis Bush wrote:But that is a falsehood.
On Tuesday, March 29, 2022 at 8:33:15 AM UTC-4, olcott wrote:
The Linz proof only examines Ĥ applied to ⟨Ĥ⟩ thus embedded_H
applied to
⟨Ĥ⟩ ⟨Ĥ⟩.
The key problem with this is that it is incorrectly assumed that ⟨Ĥ⟩
⟨Ĥ⟩ simulated outside of Ĥ must have the same behavior as ⟨Ĥ⟩ ⟨Ĥ⟩
simulated inside of Ĥ even after it is conclusively proved that they
have distinctly different behavior for this reason:
The directly executed Ĥ applied to ⟨Ĥ⟩ is the first invocation of
infinite recursion that only terminates normally because of its
one-way dependency relationship on embedded_H aborting the second
invocation of this otherwise infinite recursion.
IF H^ applied to <H^ > Halts for ANY reason, it Halts.
All simulations of a given machine MUST match the behavior of the
machine itself,
or BY DEFINITION, they are NOT a CORRECT Simulation, and
al copies of a given Turing Mchine when given the same input must behave
the same.
This has been pointed out to you mny times, and you refuse to show an
actual counter example to prove your claim.
THis shows you are just a hypocritical pathological liar who doesn't understand a thing about the field.
On Wednesday, March 30, 2022 at 12:17:25 PM UTC-4, olcott wrote:
On 3/30/2022 10:58 AM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 11:40:07 AM UTC-4, olcott wrote:Like I said I will not tolerate endless strawman errors.
On 3/30/2022 8:13 AM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 8:59:34 AM UTC-4, olcott wrote:Where N is the number of simulated steps required to correctly match an >>>> infinite behavior pattern such that the input is correctly proved to
On 3/30/2022 7:06 AM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 12:02:48 AM UTC-4, olcott wrote: >>>>>>>> On 3/29/2022 10:52 PM, Dennis Bush wrote:All that you are saying is that a halt determiner that was intentionally >>>>>> designed to get the wrong answer does get the wrong answer. It is not >>>>>> any rebuttal of my words at all and you know it.
On Tuesday, March 29, 2022 at 11:33:05 PM UTC-4, olcott wrote: >>>>>>>>>> On 3/29/2022 7:45 AM, Dennis Bush wrote:It is self evidently that the simulated input to embedded_H cannot >>>>>>>> possibly reach its own final state of ⟨Ĥ.qn⟩ in any finite number of
On Tuesday, March 29, 2022 at 8:33:15 AM UTC-4, olcott wrote: >>>>>>>>>>The key problem with this is that it is incorrectly assumed that ⟨Ĥ⟩ ⟨Ĥ⟩
The Linz proof only examines Ĥ applied to ⟨Ĥ⟩ thus embedded_H applied to
⟨Ĥ⟩ ⟨Ĥ⟩.
simulated outside of Ĥ must have the same behavior as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated
inside of Ĥ even after it is conclusively proved that they have >>>>>>>>>> distinctly different behavior
And by "distinctly different behavior" you mean "embedded_H simulated Ĥ applied to ⟨Ĥ⟩ incorrectly",
steps of correct simulation by embedded_H and you know it.
And by the same logic, It is self evidentl that the simulated input <N><5> to H3a cannot possibly reach its own final state of <N.qy> in any finite number of steps of correct simulation by H3a and you know it.
H3a can correctly determine that <Infinite_Loop><> is non-halting, correct? So it's just a matter of determining how to find it it gets the right answer.
I will change my words so that your spec meets these changed words: >>>>>> It is self evidently correct that the simulated input to h3a cannot >>>>>> possibly reach its own final state of ⟨N.qy⟩ in any insufficient number
number of steps of correct simulation by H3a.
My specs says 1.. ∞ steps your spec says 1 .. 3 steps
embedded_Ha doesn't simulate <Ha^><Ha^> for infinite steps either. It simulates for up to some n number of steps.
never reach its own final state or N is the number of simulated steps
required for the input to reach its own final state.
Hb simulates <Ha^><Ha^>
Translation: "I will not tolerate any solid arguments that conclusively prove I am wrong."
If Hb accepting <Ha^><Ha^> is wrong
On Wednesday, March 30, 2022 at 11:40:07 AM UTC-4, olcott wrote:
On 3/30/2022 8:13 AM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 8:59:34 AM UTC-4, olcott wrote:Where N is the number of simulated steps required to correctly match an
On 3/30/2022 7:06 AM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 12:02:48 AM UTC-4, olcott wrote:All that you are saying is that a halt determiner that was intentionally >>>> designed to get the wrong answer does get the wrong answer. It is not
On 3/29/2022 10:52 PM, Dennis Bush wrote:
On Tuesday, March 29, 2022 at 11:33:05 PM UTC-4, olcott wrote:It is self evidently that the simulated input to embedded_H cannot >>>>>> possibly reach its own final state of ⟨Ĥ.qn⟩ in any finite number of
On 3/29/2022 7:45 AM, Dennis Bush wrote:
On Tuesday, March 29, 2022 at 8:33:15 AM UTC-4, olcott wrote: >>>>>>>>The key problem with this is that it is incorrectly assumed that ⟨Ĥ⟩ ⟨Ĥ⟩
The Linz proof only examines Ĥ applied to ⟨Ĥ⟩ thus embedded_H applied to
⟨Ĥ⟩ ⟨Ĥ⟩.
simulated outside of Ĥ must have the same behavior as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated
inside of Ĥ even after it is conclusively proved that they have >>>>>>>> distinctly different behavior
And by "distinctly different behavior" you mean "embedded_H simulated Ĥ applied to ⟨Ĥ⟩ incorrectly",
steps of correct simulation by embedded_H and you know it.
And by the same logic, It is self evidentl that the simulated input <N><5> to H3a cannot possibly reach its own final state of <N.qy> in any finite number of steps of correct simulation by H3a and you know it.
any rebuttal of my words at all and you know it.
H3a can correctly determine that <Infinite_Loop><> is non-halting, correct? So it's just a matter of determining how to find it it gets the right answer.
I will change my words so that your spec meets these changed words:
It is self evidently correct that the simulated input to h3a cannot
possibly reach its own final state of ⟨N.qy⟩ in any insufficient number
number of steps of correct simulation by H3a.
My specs says 1.. ∞ steps your spec says 1 .. 3 steps
embedded_Ha doesn't simulate <Ha^><Ha^> for infinite steps either. It simulates for up to some n number of steps.
infinite behavior pattern such that the input is correctly proved to
never reach its own final state or N is the number of simulated steps
required for the input to reach its own final state.
Hb simulates <Ha^><Ha^>
On Wednesday, March 30, 2022 at 12:40:04 PM UTC-4, olcott wrote:and therefore embedded_Ha did *not* simulate enough steps of <Ha^><Ha^> and gets the wrong answer.
On 3/30/2022 11:26 AM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 12:17:25 PM UTC-4, olcott wrote:It would be that it violated the specification thus no more than a
On 3/30/2022 10:58 AM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 11:40:07 AM UTC-4, olcott wrote:Like I said I will not tolerate endless strawman errors.
On 3/30/2022 8:13 AM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 8:59:34 AM UTC-4, olcott wrote: >>>>>>>> On 3/30/2022 7:06 AM, Dennis Bush wrote:Where N is the number of simulated steps required to correctly match an >>>>>> infinite behavior pattern such that the input is correctly proved to >>>>>> never reach its own final state or N is the number of simulated steps >>>>>> required for the input to reach its own final state.
On Wednesday, March 30, 2022 at 12:02:48 AM UTC-4, olcott wrote: >>>>>>>>>> On 3/29/2022 10:52 PM, Dennis Bush wrote:All that you are saying is that a halt determiner that was intentionally
On Tuesday, March 29, 2022 at 11:33:05 PM UTC-4, olcott wrote: >>>>>>>>>>>> On 3/29/2022 7:45 AM, Dennis Bush wrote:It is self evidently that the simulated input to embedded_H cannot >>>>>>>>>> possibly reach its own final state of ⟨Ĥ.qn⟩ in any finite number of
On Tuesday, March 29, 2022 at 8:33:15 AM UTC-4, olcott wrote: >>>>>>>>>>>>The key problem with this is that it is incorrectly assumed that ⟨Ĥ⟩ ⟨Ĥ⟩
The Linz proof only examines Ĥ applied to ⟨Ĥ⟩ thus embedded_H applied to
⟨Ĥ⟩ ⟨Ĥ⟩.
simulated outside of Ĥ must have the same behavior as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated
inside of Ĥ even after it is conclusively proved that they have >>>>>>>>>>>> distinctly different behavior
And by "distinctly different behavior" you mean "embedded_H simulated Ĥ applied to ⟨Ĥ⟩ incorrectly",
steps of correct simulation by embedded_H and you know it.
And by the same logic, It is self evidentl that the simulated input <N><5> to H3a cannot possibly reach its own final state of <N.qy> in any finite number of steps of correct simulation by H3a and you know it.
designed to get the wrong answer does get the wrong answer. It is not >>>>>>>> any rebuttal of my words at all and you know it.
H3a can correctly determine that <Infinite_Loop><> is non-halting, correct? So it's just a matter of determining how to find it it gets the right answer.
I will change my words so that your spec meets these changed words: >>>>>>>> It is self evidently correct that the simulated input to h3a cannot >>>>>>>> possibly reach its own final state of ⟨N.qy⟩ in any insufficient number
number of steps of correct simulation by H3a.
My specs says 1.. ∞ steps your spec says 1 .. 3 steps
embedded_Ha doesn't simulate <Ha^><Ha^> for infinite steps either. It simulates for up to some n number of steps.
Hb simulates <Ha^><Ha^>
Translation: "I will not tolerate any solid arguments that conclusively prove I am wrong."
If Hb accepting <Ha^><Ha^> is wrong
strawman error.
It does not violate the specification. The simulating halt decider Hb simulates enough steps of its input <Ha^><Ha^> to correctly determine that its input reaches its final state of <Ha^.qn> therefore it is correct to accept it. This means that Ha
On Wednesday, March 30, 2022 at 1:12:48 PM UTC-4, olcott wrote:and therefore embedded_Ha did *not* simulate enough steps of <Ha^><Ha^> and gets the wrong answer.
On 3/30/2022 12:10 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 1:03:43 PM UTC-4, olcott wrote:
On 3/30/2022 11:53 AM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 12:40:04 PM UTC-4, olcott wrote:
On 3/30/2022 11:26 AM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 12:17:25 PM UTC-4, olcott wrote: >>>>>>>> On 3/30/2022 10:58 AM, Dennis Bush wrote:It would be that it violated the specification thus no more than a >>>>>> strawman error.
On Wednesday, March 30, 2022 at 11:40:07 AM UTC-4, olcott wrote: >>>>>>>>>> On 3/30/2022 8:13 AM, Dennis Bush wrote:Like I said I will not tolerate endless strawman errors.
On Wednesday, March 30, 2022 at 8:59:34 AM UTC-4, olcott wrote: >>>>>>>>>>>> On 3/30/2022 7:06 AM, Dennis Bush wrote:Where N is the number of simulated steps required to correctly match an
On Wednesday, March 30, 2022 at 12:02:48 AM UTC-4, olcott wrote: >>>>>>>>>>>>>> On 3/29/2022 10:52 PM, Dennis Bush wrote:All that you are saying is that a halt determiner that was intentionally
And by the same logic, It is self evidentl that the simulated input <N><5> to H3a cannot possibly reach its own final state of <N.qy> in any finite number of steps of correct simulation by H3a and you know it.On Tuesday, March 29, 2022 at 11:33:05 PM UTC-4, olcott wrote: >>>>>>>>>>>>>>>> On 3/29/2022 7:45 AM, Dennis Bush wrote:It is self evidently that the simulated input to embedded_H cannot
On Tuesday, March 29, 2022 at 8:33:15 AM UTC-4, olcott wrote: >>>>>>>>>>>>>>>>The key problem with this is that it is incorrectly assumed that ⟨Ĥ⟩ ⟨Ĥ⟩
The Linz proof only examines Ĥ applied to ⟨Ĥ⟩ thus embedded_H applied to
⟨Ĥ⟩ ⟨Ĥ⟩.
simulated outside of Ĥ must have the same behavior as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated
inside of Ĥ even after it is conclusively proved that they have
distinctly different behavior
And by "distinctly different behavior" you mean "embedded_H simulated Ĥ applied to ⟨Ĥ⟩ incorrectly",
possibly reach its own final state of ⟨Ĥ.qn⟩ in any finite number of
steps of correct simulation by embedded_H and you know it. >>>>>>>>>>>>>
designed to get the wrong answer does get the wrong answer. It is not
any rebuttal of my words at all and you know it.
H3a can correctly determine that <Infinite_Loop><> is non-halting, correct? So it's just a matter of determining how to find it it gets the right answer.
embedded_Ha doesn't simulate <Ha^><Ha^> for infinite steps either. It simulates for up to some n number of steps.
I will change my words so that your spec meets these changed words:
It is self evidently correct that the simulated input to h3a cannot
possibly reach its own final state of ⟨N.qy⟩ in any insufficient number
number of steps of correct simulation by H3a.
My specs says 1.. ∞ steps your spec says 1 .. 3 steps >>>>>>>>>>>
infinite behavior pattern such that the input is correctly proved to >>>>>>>>>> never reach its own final state or N is the number of simulated steps
required for the input to reach its own final state.
Hb simulates <Ha^><Ha^>
Translation: "I will not tolerate any solid arguments that conclusively prove I am wrong."
If Hb accepting <Ha^><Ha^> is wrong
It does not violate the specification. The simulating halt decider Hb simulates enough steps of its input <Ha^><Ha^> to correctly determine that its input reaches its final state of <Ha^.qn> therefore it is correct to accept it. This means that Ha
Then it violates the spec and is merely a dishonest attempt at theTHERE CANNOT POSSIBLY BE ANY CORRECT REBUTTAL TO THIS:
When embedded_H simulates enough steps of its input ⟨Ĥ⟩ ⟨Ĥ⟩ to correctly
determine that this input cannot possibly reach its own final state of >>>> ⟨Ĥ.qn⟩ then embedded_H would be correct to reject this input.
embedded_Ha does *not* simulate enough steps of its input <Ha^><Ha^> .
strawman error.
How does it violate the spec?
On Wednesday, March 30, 2022 at 1:29:19 PM UTC-4, olcott wrote:Ha and therefore embedded_Ha did *not* simulate enough steps of <Ha^><Ha^> and gets the wrong answer.
On 3/30/2022 12:20 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 1:12:48 PM UTC-4, olcott wrote:
On 3/30/2022 12:10 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 1:03:43 PM UTC-4, olcott wrote:
On 3/30/2022 11:53 AM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 12:40:04 PM UTC-4, olcott wrote: >>>>>>>> On 3/30/2022 11:26 AM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 12:17:25 PM UTC-4, olcott wrote: >>>>>>>>>> On 3/30/2022 10:58 AM, Dennis Bush wrote:It would be that it violated the specification thus no more than a >>>>>>>> strawman error.
On Wednesday, March 30, 2022 at 11:40:07 AM UTC-4, olcott wrote: >>>>>>>>>>>> On 3/30/2022 8:13 AM, Dennis Bush wrote:Like I said I will not tolerate endless strawman errors.
On Wednesday, March 30, 2022 at 8:59:34 AM UTC-4, olcott wrote: >>>>>>>>>>>>>> On 3/30/2022 7:06 AM, Dennis Bush wrote:Where N is the number of simulated steps required to correctly match an
On Wednesday, March 30, 2022 at 12:02:48 AM UTC-4, olcott wrote:All that you are saying is that a halt determiner that was intentionally
On 3/29/2022 10:52 PM, Dennis Bush wrote:And by the same logic, It is self evidentl that the simulated input <N><5> to H3a cannot possibly reach its own final state of <N.qy> in any finite number of steps of correct simulation by H3a and you know it.
On Tuesday, March 29, 2022 at 11:33:05 PM UTC-4, olcott wrote:It is self evidently that the simulated input to embedded_H cannot
On 3/29/2022 7:45 AM, Dennis Bush wrote:
On Tuesday, March 29, 2022 at 8:33:15 AM UTC-4, olcott wrote:The key problem with this is that it is incorrectly assumed that ⟨Ĥ⟩ ⟨Ĥ⟩
The Linz proof only examines Ĥ applied to ⟨Ĥ⟩ thus embedded_H applied to
⟨Ĥ⟩ ⟨Ĥ⟩.
simulated outside of Ĥ must have the same behavior as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated
inside of Ĥ even after it is conclusively proved that they have
distinctly different behavior
And by "distinctly different behavior" you mean "embedded_H simulated Ĥ applied to ⟨Ĥ⟩ incorrectly",
possibly reach its own final state of ⟨Ĥ.qn⟩ in any finite number of
steps of correct simulation by embedded_H and you know it. >>>>>>>>>>>>>>>
designed to get the wrong answer does get the wrong answer. It is not
any rebuttal of my words at all and you know it.
H3a can correctly determine that <Infinite_Loop><> is non-halting, correct? So it's just a matter of determining how to find it it gets the right answer.
embedded_Ha doesn't simulate <Ha^><Ha^> for infinite steps either. It simulates for up to some n number of steps.
I will change my words so that your spec meets these changed words:
It is self evidently correct that the simulated input to h3a cannot
possibly reach its own final state of ⟨N.qy⟩ in any insufficient number
number of steps of correct simulation by H3a.
My specs says 1.. ∞ steps your spec says 1 .. 3 steps >>>>>>>>>>>>>
infinite behavior pattern such that the input is correctly proved to
never reach its own final state or N is the number of simulated steps
required for the input to reach its own final state.
Hb simulates <Ha^><Ha^>
Translation: "I will not tolerate any solid arguments that conclusively prove I am wrong."
If Hb accepting <Ha^><Ha^> is wrong
It does not violate the specification. The simulating halt decider Hb simulates enough steps of its input <Ha^><Ha^> to correctly determine that its input reaches its final state of <Ha^.qn> therefore it is correct to accept it. This means that
embedded_H DOES SIMULATE ENOUGH STEPS.strawman error.THERE CANNOT POSSIBLY BE ANY CORRECT REBUTTAL TO THIS:
When embedded_H simulates enough steps of its input ⟨Ĥ⟩ ⟨Ĥ⟩ to correctly
determine that this input cannot possibly reach its own final state of >>>>>> ⟨Ĥ.qn⟩ then embedded_H would be correct to reject this input.
embedded_Ha does *not* simulate enough steps of its input <Ha^><Ha^> . >>>> Then it violates the spec and is merely a dishonest attempt at the
How does it violate the spec?
embedded_Ha IS REQUIRED TO SIMULATE ENOUGH STEPS OR IT VIOLATES THE SPEC.
On 3/30/2022 3:10 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 3:54:50 PM UTC-4, olcott wrote:
On 3/30/2022 12:37 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 1:29:19 PM UTC-4, olcott wrote:HHH always simulates its input until it has proof that its simulated
On 3/30/2022 12:20 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 1:12:48 PM UTC-4, olcott wrote:embedded_H DOES SIMULATE ENOUGH STEPS.
On 3/30/2022 12:10 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 1:03:43 PM UTC-4, olcott wrote: >>>>>>>>> On 3/30/2022 11:53 AM, Dennis Bush wrote:Then it violates the spec and is merely a dishonest attempt at the >>>>>>> strawman error.
embedded_Ha does *not* simulate enough steps of its inputOn Wednesday, March 30, 2022 at 12:40:04 PM UTC-4, olcott wrote: >>>>>>>>>>> On 3/30/2022 11:26 AM, Dennis Bush wrote:THERE CANNOT POSSIBLY BE ANY CORRECT REBUTTAL TO THIS:
On Wednesday, March 30, 2022 at 12:17:25 PM UTC-4, olcott >>>>>>>>>>>> wrote:It would be that it violated the specification thus no more >>>>>>>>>>> than a
On 3/30/2022 10:58 AM, Dennis Bush wrote:Translation: "I will not tolerate any solid arguments that >>>>>>>>>>>> conclusively prove I am wrong."
On Wednesday, March 30, 2022 at 11:40:07 AM UTC-4, olcott >>>>>>>>>>>>>> wrote:Like I said I will not tolerate endless strawman errors. >>>>>>>>>>>>
On 3/30/2022 8:13 AM, Dennis Bush wrote:Hb simulates <Ha^><Ha^>
On Wednesday, March 30, 2022 at 8:59:34 AM UTC-4, olcott >>>>>>>>>>>>>>>> wrote:Where N is the number of simulated steps required to >>>>>>>>>>>>>>> correctly match an
On 3/30/2022 7:06 AM, Dennis Bush wrote:H3a can correctly determine that <Infinite_Loop><> is >>>>>>>>>>>>>>>> non-halting, correct? So it's just a matter of >>>>>>>>>>>>>>>> determining how to find it it gets the right answer. >>>>>>>>>>>>>>>>
On Wednesday, March 30, 2022 at 12:02:48 AM UTC-4, >>>>>>>>>>>>>>>>>> olcott wrote:All that you are saying is that a halt determiner that >>>>>>>>>>>>>>>>> was intentionally
On 3/29/2022 10:52 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>> On Tuesday, March 29, 2022 at 11:33:05 PM UTC-4, >>>>>>>>>>>>>>>>>>>> olcott wrote:
possibly reach its own final state of ⟨Ĥ.qn⟩ in any >>>>>>>>>>>>>>>>>>> finite number ofOn 3/29/2022 7:45 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>> On Tuesday, March 29, 2022 at 8:33:15 AM UTC-4, >>>>>>>>>>>>>>>>>>>>>> olcott wrote:
The key problem with this is that it is incorrectly >>>>>>>>>>>>>>>>>>>>> assumed that ⟨Ĥ⟩ ⟨Ĥ⟩The Linz proof only examines Ĥ applied to ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>>>>>> thus embedded_H applied to
⟨Ĥ⟩ ⟨Ĥ⟩.
simulated outside of Ĥ must have the same behavior >>>>>>>>>>>>>>>>>>>>> as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated
inside of Ĥ even after it is conclusively proved >>>>>>>>>>>>>>>>>>>>> that they have
distinctly different behavior
And by "distinctly different behavior" you mean >>>>>>>>>>>>>>>>>>>> "embedded_H simulated Ĥ applied to ⟨Ĥ⟩ incorrectly", >>>>>>>>>>>>>>>>>>> It is self evidently that the simulated input to >>>>>>>>>>>>>>>>>>> embedded_H cannot
steps of correct simulation by embedded_H and you >>>>>>>>>>>>>>>>>>> know it.
And by the same logic, It is self evidentl that the >>>>>>>>>>>>>>>>>> simulated input <N><5> to H3a cannot possibly reach >>>>>>>>>>>>>>>>>> its own final state of <N.qy> in any finite number of >>>>>>>>>>>>>>>>>> steps of correct simulation by H3a and you know it. >>>>>>>>>>>>>>>>>>
designed to get the wrong answer does get the wrong >>>>>>>>>>>>>>>>> answer. It is not
any rebuttal of my words at all and you know it. >>>>>>>>>>>>>>>>
embedded_Ha doesn't simulate <Ha^><Ha^> for infinite >>>>>>>>>>>>>>>> steps either. It simulates for up to some n number of >>>>>>>>>>>>>>>> steps.
I will change my words so that your spec meets these >>>>>>>>>>>>>>>>> changed words:
It is self evidently correct that the simulated input >>>>>>>>>>>>>>>>> to h3a cannot
possibly reach its own final state of ⟨N.qy⟩ in any >>>>>>>>>>>>>>>>> insufficient number
number of steps of correct simulation by H3a. >>>>>>>>>>>>>>>>>
My specs says 1.. ∞ steps your spec says 1 .. 3 steps >>>>>>>>>>>>>>>>
infinite behavior pattern such that the input is >>>>>>>>>>>>>>> correctly proved to
never reach its own final state or N is the number of >>>>>>>>>>>>>>> simulated steps
required for the input to reach its own final state. >>>>>>>>>>>>>>
If Hb accepting <Ha^><Ha^> is wrong
strawman error.
It does not violate the specification. The simulating halt >>>>>>>>>> decider Hb simulates enough steps of its input <Ha^><Ha^> to >>>>>>>>>> correctly determine that its input reaches its final state of >>>>>>>>>> <Ha^.qn> therefore it is correct to accept it. This means that >>>>>>>>>> Ha and therefore embedded_Ha did *not* simulate enough steps >>>>>>>>>> of <Ha^><Ha^> and gets the wrong answer.
When embedded_H simulates enough steps of its input ⟨Ĥ⟩ ⟨Ĥ⟩ to
correctly
determine that this input cannot possibly reach its own final >>>>>>>>> state of
⟨Ĥ.qn⟩ then embedded_H would be correct to reject this input. >>>>>>>>
<Ha^><Ha^> .
How does it violate the spec?
embedded_Ha IS REQUIRED TO SIMULATE ENOUGH STEPS OR IT VIOLATES THE
SPEC.
input never reaches its own final state or its simulated input reaches
its own final state.
Try and find an input that HHH does not decide correctly, everything
else is merely a deceitful attempt to get away with the strawman error.
Assuming HHH is Ha
We absolutely do not assume that.
We only assume that HHH has the proeperties shown above.
On Wednesday, March 30, 2022 at 4:53:37 PM UTC-4, olcott wrote:
On 3/30/2022 3:28 PM, olcott wrote:
On 3/30/2022 3:10 PM, Dennis Bush wrote:// NO INFINITE LOOP
On Wednesday, March 30, 2022 at 3:54:50 PM UTC-4, olcott wrote:
On 3/30/2022 12:37 PM, Dennis Bush wrote:Assuming HHH is Ha
On Wednesday, March 30, 2022 at 1:29:19 PM UTC-4, olcott wrote:HHH always simulates its input until it has proof that its simulated >>>>> input never reaches its own final state or its simulated input reaches >>>>> its own final state.
On 3/30/2022 12:20 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 1:12:48 PM UTC-4, olcott wrote: >>>>>>>>> On 3/30/2022 12:10 PM, Dennis Bush wrote:embedded_H DOES SIMULATE ENOUGH STEPS.
On Wednesday, March 30, 2022 at 1:03:43 PM UTC-4, olcott wrote: >>>>>>>>>>> On 3/30/2022 11:53 AM, Dennis Bush wrote:Then it violates the spec and is merely a dishonest attempt at the >>>>>>>>> strawman error.
embedded_Ha does *not* simulate enough steps of its inputOn Wednesday, March 30, 2022 at 12:40:04 PM UTC-4, olcott wrote: >>>>>>>>>>>>> On 3/30/2022 11:26 AM, Dennis Bush wrote:THERE CANNOT POSSIBLY BE ANY CORRECT REBUTTAL TO THIS:
On Wednesday, March 30, 2022 at 12:17:25 PM UTC-4, olcott >>>>>>>>>>>>>> wrote:It would be that it violated the specification thus no more >>>>>>>>>>>>> than a
On 3/30/2022 10:58 AM, Dennis Bush wrote:Translation: "I will not tolerate any solid arguments that >>>>>>>>>>>>>> conclusively prove I am wrong."
On Wednesday, March 30, 2022 at 11:40:07 AM UTC-4, olcott >>>>>>>>>>>>>>>> wrote:Like I said I will not tolerate endless strawman errors. >>>>>>>>>>>>>>
On 3/30/2022 8:13 AM, Dennis Bush wrote:Hb simulates <Ha^><Ha^>
On Wednesday, March 30, 2022 at 8:59:34 AM UTC-4, olcott >>>>>>>>>>>>>>>>>> wrote:Where N is the number of simulated steps required to >>>>>>>>>>>>>>>>> correctly match an
On 3/30/2022 7:06 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 12:02:48 AM UTC-4, >>>>>>>>>>>>>>>>>>>> olcott wrote:H3a can correctly determine that <Infinite_Loop><> is >>>>>>>>>>>>>>>>>> non-halting, correct? So it's just a matter of >>>>>>>>>>>>>>>>>> determining how to find it it gets the right answer. >>>>>>>>>>>>>>>>>>
All that you are saying is that a halt determiner that >>>>>>>>>>>>>>>>>>> was intentionallyOn 3/29/2022 10:52 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>> On Tuesday, March 29, 2022 at 11:33:05 PM UTC-4, >>>>>>>>>>>>>>>>>>>>>> olcott wrote:
It is self evidently that the simulated input to >>>>>>>>>>>>>>>>>>>>> embedded_H cannotOn 3/29/2022 7:45 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, March 29, 2022 at 8:33:15 AM UTC-4, >>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
The key problem with this is that it is incorrectly >>>>>>>>>>>>>>>>>>>>>>> assumed that ⟨Ĥ⟩ ⟨Ĥ⟩The Linz proof only examines Ĥ applied to ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>>>>>>>> thus embedded_H applied to
⟨Ĥ⟩ ⟨Ĥ⟩.
simulated outside of Ĥ must have the same behavior >>>>>>>>>>>>>>>>>>>>>>> as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated
inside of Ĥ even after it is conclusively proved >>>>>>>>>>>>>>>>>>>>>>> that they have
distinctly different behavior
And by "distinctly different behavior" you mean >>>>>>>>>>>>>>>>>>>>>> "embedded_H simulated Ĥ applied to ⟨Ĥ⟩ incorrectly",
possibly reach its own final state of ⟨Ĥ.qn⟩ in any >>>>>>>>>>>>>>>>>>>>> finite number of
steps of correct simulation by embedded_H and you >>>>>>>>>>>>>>>>>>>>> know it.
And by the same logic, It is self evidentl that the >>>>>>>>>>>>>>>>>>>> simulated input <N><5> to H3a cannot possibly reach >>>>>>>>>>>>>>>>>>>> its own final state of <N.qy> in any finite number of >>>>>>>>>>>>>>>>>>>> steps of correct simulation by H3a and you know it. >>>>>>>>>>>>>>>>>>>>
designed to get the wrong answer does get the wrong >>>>>>>>>>>>>>>>>>> answer. It is not
any rebuttal of my words at all and you know it. >>>>>>>>>>>>>>>>>>
embedded_Ha doesn't simulate <Ha^><Ha^> for infinite >>>>>>>>>>>>>>>>>> steps either. It simulates for up to some n number of >>>>>>>>>>>>>>>>>> steps.
I will change my words so that your spec meets these >>>>>>>>>>>>>>>>>>> changed words:
It is self evidently correct that the simulated input >>>>>>>>>>>>>>>>>>> to h3a cannot
possibly reach its own final state of ⟨N.qy⟩ in any >>>>>>>>>>>>>>>>>>> insufficient number
number of steps of correct simulation by H3a. >>>>>>>>>>>>>>>>>>>
My specs says 1.. ∞ steps your spec says 1 .. 3 steps >>>>>>>>>>>>>>>>>>
infinite behavior pattern such that the input is >>>>>>>>>>>>>>>>> correctly proved to
never reach its own final state or N is the number of >>>>>>>>>>>>>>>>> simulated steps
required for the input to reach its own final state. >>>>>>>>>>>>>>>>
If Hb accepting <Ha^><Ha^> is wrong
strawman error.
It does not violate the specification. The simulating halt >>>>>>>>>>>> decider Hb simulates enough steps of its input <Ha^><Ha^> to >>>>>>>>>>>> correctly determine that its input reaches its final state of >>>>>>>>>>>> <Ha^.qn> therefore it is correct to accept it. This means that >>>>>>>>>>>> Ha and therefore embedded_Ha did *not* simulate enough steps >>>>>>>>>>>> of <Ha^><Ha^> and gets the wrong answer.
When embedded_H simulates enough steps of its input ⟨Ĥ⟩ ⟨Ĥ⟩ to
correctly
determine that this input cannot possibly reach its own final >>>>>>>>>>> state of
⟨Ĥ.qn⟩ then embedded_H would be correct to reject this input. >>>>>>>>>>
<Ha^><Ha^> .
How does it violate the spec?
embedded_Ha IS REQUIRED TO SIMULATE ENOUGH STEPS OR IT VIOLATES THE >>>>>>> SPEC.
Try and find an input that HHH does not decide correctly, everything >>>>> else is merely a deceitful attempt to get away with the strawman error. >>>>
We absolutely do not assume that.
We only assume that HHH has the proeperties shown above.
// NO INFINITE LOOP
// NO INFINITE LOOP
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy // NO INFINITE LOOP >> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
state.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
final state.
Both embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ transition to their final reject
state as soon as they see an identical copy of embedded_H being
simulated with identical input.
Recalling that the H above can also be referred to as Ha to denote a halt decider that aborts with the infinite simulation logic and Ha^ is built from Ha:
We can give the input <Ha^><Ha^> to Hb, which simulates for some k steps more than Ha,
On 3/30/22 4:57 PM, olcott wrote:
On 3/30/2022 3:53 PM, Ben Bacarisse wrote:
Dennis Bush <dbush.mobile@gmail.com> writes:Not at all. I can can no longer afford to tolerate the endless cycle
On Wednesday, March 30, 2022 at 3:54:50 PM UTC-4, olcott wrote:
HHH always simulates its input until it has proof that its simulated >>>>> input never reaches its own final state or its simulated input reaches >>>>> its own final state.
Try and find an input that HHH does not decide correctly, everything >>>>> else is merely a deceitful attempt to get away with the strawman
error.
Assuming HHH is Ha / embedded_Ha, Ha rejects the input <Ha^><Ha^>
based on what it believe to be an infinite simulation. Hb simulates
the input <Ha^><Ha^> for longer than Ha, where it sees that the
simulated input reaches its own final state. Hb then accepts this
input, therefore Ha rejecting the input <Ha^><Ha^> is wrong.
PO is not good at notation. He can see that your argument is correct,
of strawman arguments. If I require my notation and my definitions
then the strawman error cannot possibly occur.
Then you have DOOMED yourself as your notation has inherent flaws.
Your Choice.
On 3/30/22 8:36 PM, olcott wrote:
On 3/30/2022 7:09 PM, Richard Damon wrote:
On 3/30/22 4:57 PM, olcott wrote:
On 3/30/2022 3:53 PM, Ben Bacarisse wrote:
Dennis Bush <dbush.mobile@gmail.com> writes:of strawman arguments. If I require my notation and my definitions
On Wednesday, March 30, 2022 at 3:54:50 PM UTC-4, olcott wrote:
HHH always simulates its input until it has proof that its simulated >>>>>>> input never reaches its own final state or its simulated input
reaches
its own final state.
Try and find an input that HHH does not decide correctly, everything >>>>>>> else is merely a deceitful attempt to get away with the strawman >>>>>>> error.
Assuming HHH is Ha / embedded_Ha, Ha rejects the input <Ha^><Ha^>
based on what it believe to be an infinite simulation. Hb simulates >>>>>> the input <Ha^><Ha^> for longer than Ha, where it sees that the
simulated input reaches its own final state. Hb then accepts this
input, therefore Ha rejecting the input <Ha^><Ha^> is wrong.
PO is not good at notation. He can see that your argument is correct, >>>> Not at all. I can can no longer afford to tolerate the endless cycle
then the strawman error cannot possibly occur.
Then you have DOOMED yourself as your notation has inherent flaws.
Your Choice.
HHH always simulates its input until it has complete proof that this
simulated input will never reach its final state or this simulated
input reaches its final state.
If the template of HHH cannot be refuted then that makes it irrefutable.
Right, and for the simulation of <H^> <H^> that takes an infinite time,
so HHH fails to meet the requrements of a Halt Decider.
REFUTED.
PROVE OTHERWISE.
FAIL.
On Wednesday, March 30, 2022 at 10:05:32 PM UTC-4, olcott wrote:to simulate <Ha^><Ha^> for a finite number of steps (n), so Hb can simulate <Ha^><Ha^> for n+k steps and see it halt.
On 3/30/2022 8:59 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 7:35:26 PM UTC-4, olcott wrote:and you just said that Ha simulates to infinity because Ha is merely
On 3/30/2022 4:01 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 4:53:37 PM UTC-4, olcott wrote:So great Hb simulates for some k steps more than infinity.
On 3/30/2022 3:28 PM, olcott wrote:
On 3/30/2022 3:10 PM, Dennis Bush wrote:// NO INFINITE LOOP
On Wednesday, March 30, 2022 at 3:54:50 PM UTC-4, olcott wrote: >>>>>>>>> On 3/30/2022 12:37 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 1:29:19 PM UTC-4, olcott wrote: >>>>>>>>>>> On 3/30/2022 12:20 PM, Dennis Bush wrote:HHH always simulates its input until it has proof that its simulated >>>>>>>>> input never reaches its own final state or its simulated input reaches
On Wednesday, March 30, 2022 at 1:12:48 PM UTC-4, olcott wrote: >>>>>>>>>>>>> On 3/30/2022 12:10 PM, Dennis Bush wrote:embedded_H DOES SIMULATE ENOUGH STEPS.
On Wednesday, March 30, 2022 at 1:03:43 PM UTC-4, olcott wrote: >>>>>>>>>>>>>>> On 3/30/2022 11:53 AM, Dennis Bush wrote:Then it violates the spec and is merely a dishonest attempt at the
On Wednesday, March 30, 2022 at 12:40:04 PM UTC-4, olcott wrote:THERE CANNOT POSSIBLY BE ANY CORRECT REBUTTAL TO THIS: >>>>>>>>>>>>>>> When embedded_H simulates enough steps of its input ⟨Ĥ⟩ ⟨Ĥ⟩ to
On 3/30/2022 11:26 AM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 12:17:25 PM UTC-4, olcott >>>>>>>>>>>>>>>>>> wrote:It would be that it violated the specification thus no more >>>>>>>>>>>>>>>>> than a
On 3/30/2022 10:58 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 11:40:07 AM UTC-4, olcott >>>>>>>>>>>>>>>>>>>> wrote:Translation: "I will not tolerate any solid arguments that >>>>>>>>>>>>>>>>>> conclusively prove I am wrong."
Like I said I will not tolerate endless strawman errors. >>>>>>>>>>>>>>>>>>On 3/30/2022 8:13 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 8:59:34 AM UTC-4, olcott >>>>>>>>>>>>>>>>>>>>>> wrote:Hb simulates <Ha^><Ha^>
Where N is the number of simulated steps required to >>>>>>>>>>>>>>>>>>>>> correctly match anOn 3/30/2022 7:06 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 12:02:48 AM UTC-4, >>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:H3a can correctly determine that <Infinite_Loop><> is >>>>>>>>>>>>>>>>>>>>>> non-halting, correct? So it's just a matter of >>>>>>>>>>>>>>>>>>>>>> determining how to find it it gets the right answer. >>>>>>>>>>>>>>>>>>>>>>
All that you are saying is that a halt determiner that >>>>>>>>>>>>>>>>>>>>>>> was intentionallyOn 3/29/2022 10:52 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, March 29, 2022 at 11:33:05 PM UTC-4, >>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
It is self evidently that the simulated input to >>>>>>>>>>>>>>>>>>>>>>>>> embedded_H cannotOn 3/29/2022 7:45 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, March 29, 2022 at 8:33:15 AM UTC-4, >>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:And by "distinctly different behavior" you mean >>>>>>>>>>>>>>>>>>>>>>>>>> "embedded_H simulated Ĥ applied to ⟨Ĥ⟩ incorrectly",
The key problem with this is that it is incorrectly >>>>>>>>>>>>>>>>>>>>>>>>>>> assumed that ⟨Ĥ⟩ ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>>>>>>>>>> simulated outside of Ĥ must have the same behavior >>>>>>>>>>>>>>>>>>>>>>>>>>> as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated >>>>>>>>>>>>>>>>>>>>>>>>>>> inside of Ĥ even after it is conclusively proved >>>>>>>>>>>>>>>>>>>>>>>>>>> that they haveThe Linz proof only examines Ĥ applied to ⟨Ĥ⟩
thus embedded_H applied to >>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩.
distinctly different behavior >>>>>>>>>>>>>>>>>>>>>>>>>>
possibly reach its own final state of ⟨Ĥ.qn⟩ in any
finite number of
steps of correct simulation by embedded_H and you >>>>>>>>>>>>>>>>>>>>>>>>> know it.
And by the same logic, It is self evidentl that the >>>>>>>>>>>>>>>>>>>>>>>> simulated input <N><5> to H3a cannot possibly reach >>>>>>>>>>>>>>>>>>>>>>>> its own final state of <N.qy> in any finite number of >>>>>>>>>>>>>>>>>>>>>>>> steps of correct simulation by H3a and you know it. >>>>>>>>>>>>>>>>>>>>>>>>
designed to get the wrong answer does get the wrong >>>>>>>>>>>>>>>>>>>>>>> answer. It is not
any rebuttal of my words at all and you know it. >>>>>>>>>>>>>>>>>>>>>>
embedded_Ha doesn't simulate <Ha^><Ha^> for infinite >>>>>>>>>>>>>>>>>>>>>> steps either. It simulates for up to some n number of >>>>>>>>>>>>>>>>>>>>>> steps.
I will change my words so that your spec meets these >>>>>>>>>>>>>>>>>>>>>>> changed words:
It is self evidently correct that the simulated input >>>>>>>>>>>>>>>>>>>>>>> to h3a cannot
possibly reach its own final state of ⟨N.qy⟩ in any >>>>>>>>>>>>>>>>>>>>>>> insufficient number
number of steps of correct simulation by H3a. >>>>>>>>>>>>>>>>>>>>>>>
My specs says 1.. ∞ steps your spec says 1 .. 3 steps >>>>>>>>>>>>>>>>>>>>>>
infinite behavior pattern such that the input is >>>>>>>>>>>>>>>>>>>>> correctly proved to
never reach its own final state or N is the number of >>>>>>>>>>>>>>>>>>>>> simulated steps
required for the input to reach its own final state. >>>>>>>>>>>>>>>>>>>>
If Hb accepting <Ha^><Ha^> is wrong
strawman error.
It does not violate the specification. The simulating halt >>>>>>>>>>>>>>>> decider Hb simulates enough steps of its input <Ha^><Ha^> to >>>>>>>>>>>>>>>> correctly determine that its input reaches its final state of >>>>>>>>>>>>>>>> <Ha^.qn> therefore it is correct to accept it. This means that >>>>>>>>>>>>>>>> Ha and therefore embedded_Ha did *not* simulate enough steps >>>>>>>>>>>>>>>> of <Ha^><Ha^> and gets the wrong answer.
correctly
determine that this input cannot possibly reach its own final >>>>>>>>>>>>>>> state of
⟨Ĥ.qn⟩ then embedded_H would be correct to reject this input.
embedded_Ha does *not* simulate enough steps of its input >>>>>>>>>>>>>> <Ha^><Ha^> .
strawman error.
How does it violate the spec?
embedded_Ha IS REQUIRED TO SIMULATE ENOUGH STEPS OR IT VIOLATES THE >>>>>>>>>>> SPEC.
its own final state.
Try and find an input that HHH does not decide correctly, everything >>>>>>>>> else is merely a deceitful attempt to get away with the strawman error.
Assuming HHH is Ha
We absolutely do not assume that.
We only assume that HHH has the proeperties shown above.
// NO INFINITE LOOP
// NO INFINITE LOOP
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy // NO INFINITE LOOP
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
state.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
final state.
Both embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ transition to their final reject
state as soon as they see an identical copy of embedded_H being
simulated with identical input.
Recalling that the H above can also be referred to as Ha to denote a halt decider that aborts with the infinite simulation logic and Ha^ is built from Ha:
We can give the input <Ha^><Ha^> to Hb, which simulates for some k steps more than Ha,
Not k more than infinity, but k more than the n steps that Ha simulates.
another name for H. It is pretty ridiculously stupid to create a new
name for identical behavior.
And that is why I'm specifically using the name Ha to refer to the H that aborts. You're now talking about Hn which doesn't abort and *actually* can run for an infinite number of steps, but is unable to report on a non-halting input. Ha is only able
On Wednesday, March 30, 2022 at 10:35:50 PM UTC-4, olcott wrote:to simulate <Ha^><Ha^> for a finite number of steps (n), so Hb can simulate <Ha^><Ha^> for n+k steps and see it halt.
On 3/30/2022 9:16 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 10:05:32 PM UTC-4, olcott wrote:
On 3/30/2022 8:59 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 7:35:26 PM UTC-4, olcott wrote:another name for H. It is pretty ridiculously stupid to create a new
On 3/30/2022 4:01 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 4:53:37 PM UTC-4, olcott wrote: >>>>>>>> On 3/30/2022 3:28 PM, olcott wrote:So great Hb simulates for some k steps more than infinity.
On 3/30/2022 3:10 PM, Dennis Bush wrote:// NO INFINITE LOOP
On Wednesday, March 30, 2022 at 3:54:50 PM UTC-4, olcott wrote: >>>>>>>>>>> On 3/30/2022 12:37 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 1:29:19 PM UTC-4, olcott wrote: >>>>>>>>>>>>> On 3/30/2022 12:20 PM, Dennis Bush wrote:HHH always simulates its input until it has proof that its simulated
On Wednesday, March 30, 2022 at 1:12:48 PM UTC-4, olcott wrote: >>>>>>>>>>>>>>> On 3/30/2022 12:10 PM, Dennis Bush wrote:embedded_H DOES SIMULATE ENOUGH STEPS.
On Wednesday, March 30, 2022 at 1:03:43 PM UTC-4, olcott wrote:Then it violates the spec and is merely a dishonest attempt at the
On 3/30/2022 11:53 AM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 12:40:04 PM UTC-4, olcott wrote:THERE CANNOT POSSIBLY BE ANY CORRECT REBUTTAL TO THIS: >>>>>>>>>>>>>>>>> When embedded_H simulates enough steps of its input ⟨Ĥ⟩ ⟨Ĥ⟩ to
On 3/30/2022 11:26 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 12:17:25 PM UTC-4, olcott >>>>>>>>>>>>>>>>>>>> wrote:
It would be that it violated the specification thus no more >>>>>>>>>>>>>>>>>>> than aOn 3/30/2022 10:58 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 11:40:07 AM UTC-4, olcottTranslation: "I will not tolerate any solid arguments that >>>>>>>>>>>>>>>>>>>> conclusively prove I am wrong."
wrote:Like I said I will not tolerate endless strawman errors. >>>>>>>>>>>>>>>>>>>>
On 3/30/2022 8:13 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 8:59:34 AM UTC-4, olcottHb simulates <Ha^><Ha^>
wrote:Where N is the number of simulated steps required to >>>>>>>>>>>>>>>>>>>>>>> correctly match an
On 3/30/2022 7:06 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 12:02:48 AM UTC-4, >>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:H3a can correctly determine that <Infinite_Loop><> is >>>>>>>>>>>>>>>>>>>>>>>> non-halting, correct? So it's just a matter of >>>>>>>>>>>>>>>>>>>>>>>> determining how to find it it gets the right answer. >>>>>>>>>>>>>>>>>>>>>>>>
All that you are saying is that a halt determiner thatOn 3/29/2022 10:52 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, March 29, 2022 at 11:33:05 PM UTC-4, >>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
It is self evidently that the simulated input to >>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H cannotOn 3/29/2022 7:45 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, March 29, 2022 at 8:33:15 AM UTC-4, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:And by "distinctly different behavior" you mean >>>>>>>>>>>>>>>>>>>>>>>>>>>> "embedded_H simulated Ĥ applied to ⟨Ĥ⟩ incorrectly",
assumed that ⟨Ĥ⟩ ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated outside of Ĥ must have the same behaviorThe Linz proof only examines Ĥ applied to ⟨Ĥ⟩
thus embedded_H applied to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>>>>>>>>>>>>> The key problem with this is that it is incorrectly
as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated >>>>>>>>>>>>>>>>>>>>>>>>>>>>> inside of Ĥ even after it is conclusively proved >>>>>>>>>>>>>>>>>>>>>>>>>>>>> that they have
distinctly different behavior >>>>>>>>>>>>>>>>>>>>>>>>>>>>
possibly reach its own final state of ⟨Ĥ.qn⟩ in any
finite number of
steps of correct simulation by embedded_H and you >>>>>>>>>>>>>>>>>>>>>>>>>>> know it.
And by the same logic, It is self evidentl that the >>>>>>>>>>>>>>>>>>>>>>>>>> simulated input <N><5> to H3a cannot possibly reach >>>>>>>>>>>>>>>>>>>>>>>>>> its own final state of <N.qy> in any finite number of
steps of correct simulation by H3a and you know it. >>>>>>>>>>>>>>>>>>>>>>>>>>
was intentionally
designed to get the wrong answer does get the wrong >>>>>>>>>>>>>>>>>>>>>>>>> answer. It is not
any rebuttal of my words at all and you know it. >>>>>>>>>>>>>>>>>>>>>>>>
I will change my words so that your spec meets these >>>>>>>>>>>>>>>>>>>>>>>>> changed words:
It is self evidently correct that the simulated input >>>>>>>>>>>>>>>>>>>>>>>>> to h3a cannot
possibly reach its own final state of ⟨N.qy⟩ in any
insufficient number
number of steps of correct simulation by H3a. >>>>>>>>>>>>>>>>>>>>>>>>>
My specs says 1.. ∞ steps your spec says 1 .. 3 steps
embedded_Ha doesn't simulate <Ha^><Ha^> for infinite >>>>>>>>>>>>>>>>>>>>>>>> steps either. It simulates for up to some n number of >>>>>>>>>>>>>>>>>>>>>>>> steps.
infinite behavior pattern such that the input is >>>>>>>>>>>>>>>>>>>>>>> correctly proved to
never reach its own final state or N is the number of >>>>>>>>>>>>>>>>>>>>>>> simulated steps
required for the input to reach its own final state. >>>>>>>>>>>>>>>>>>>>>>
If Hb accepting <Ha^><Ha^> is wrong
strawman error.
It does not violate the specification. The simulating halt >>>>>>>>>>>>>>>>>> decider Hb simulates enough steps of its input <Ha^><Ha^> to >>>>>>>>>>>>>>>>>> correctly determine that its input reaches its final state of
<Ha^.qn> therefore it is correct to accept it. This means that
Ha and therefore embedded_Ha did *not* simulate enough steps >>>>>>>>>>>>>>>>>> of <Ha^><Ha^> and gets the wrong answer.
correctly
determine that this input cannot possibly reach its own final >>>>>>>>>>>>>>>>> state of
⟨Ĥ.qn⟩ then embedded_H would be correct to reject this input.
embedded_Ha does *not* simulate enough steps of its input >>>>>>>>>>>>>>>> <Ha^><Ha^> .
strawman error.
How does it violate the spec?
embedded_Ha IS REQUIRED TO SIMULATE ENOUGH STEPS OR IT VIOLATES THE
SPEC.
input never reaches its own final state or its simulated input reaches
its own final state.
Try and find an input that HHH does not decide correctly, everything
else is merely a deceitful attempt to get away with the strawman error.
Assuming HHH is Ha
We absolutely do not assume that.
We only assume that HHH has the proeperties shown above.
// NO INFINITE LOOP
// NO INFINITE LOOP
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy // NO INFINITE LOOP
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
state.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
final state.
Both embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ transition to their final reject
state as soon as they see an identical copy of embedded_H being >>>>>>>> simulated with identical input.
Recalling that the H above can also be referred to as Ha to denote a halt decider that aborts with the infinite simulation logic and Ha^ is built from Ha:
We can give the input <Ha^><Ha^> to Hb, which simulates for some k steps more than Ha,
Not k more than infinity, but k more than the n steps that Ha simulates. >>>> and you just said that Ha simulates to infinity because Ha is merely
name for identical behavior.
And that is why I'm specifically using the name Ha to refer to the H that aborts. You're now talking about Hn which doesn't abort and *actually* can run for an infinite number of steps, but is unable to report on a non-halting input. Ha is only able
All of those permutations are moot. We don't need to look at any of them
that get the wrong answer we only need to examine the one that gets the
right answer and then see how Ĥ plugs in to this one.
So how exactly does Hb get the wrong answer for <Ha^><Ha^>?
HHH always simulates its input until it has complete proof that this
simulated input will never reach its final state or this simulated input
reaches its final state.
If the template of HHH cannot be refuted then that makes it irrefutable.
I'll tell you a secret: the Linz proof assumes that HHH exists and then proves that it gets the HHH^ case wrong, showing that it actually can't exist.
On Wednesday, March 30, 2022 at 10:52:11 PM UTC-4, olcott wrote:able to simulate <Ha^><Ha^> for a finite number of steps (n), so Hb can simulate <Ha^><Ha^> for n+k steps and see it halt.
On 3/30/2022 9:40 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 10:35:50 PM UTC-4, olcott wrote:
On 3/30/2022 9:16 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 10:05:32 PM UTC-4, olcott wrote:
On 3/30/2022 8:59 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 7:35:26 PM UTC-4, olcott wrote: >>>>>>>> On 3/30/2022 4:01 PM, Dennis Bush wrote:and you just said that Ha simulates to infinity because Ha is merely >>>>>> another name for H. It is pretty ridiculously stupid to create a new >>>>>> name for identical behavior.
On Wednesday, March 30, 2022 at 4:53:37 PM UTC-4, olcott wrote: >>>>>>>>>> On 3/30/2022 3:28 PM, olcott wrote:So great Hb simulates for some k steps more than infinity.
On 3/30/2022 3:10 PM, Dennis Bush wrote:// NO INFINITE LOOP
On Wednesday, March 30, 2022 at 3:54:50 PM UTC-4, olcott wrote: >>>>>>>>>>>>> On 3/30/2022 12:37 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 1:29:19 PM UTC-4, olcott wrote: >>>>>>>>>>>>>>> On 3/30/2022 12:20 PM, Dennis Bush wrote:HHH always simulates its input until it has proof that its simulated
On Wednesday, March 30, 2022 at 1:12:48 PM UTC-4, olcott wrote:embedded_H DOES SIMULATE ENOUGH STEPS.
On 3/30/2022 12:10 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 1:03:43 PM UTC-4, olcott wrote:Then it violates the spec and is merely a dishonest attempt at the
On 3/30/2022 11:53 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 12:40:04 PM UTC-4, olcott wrote:
correctlyOn 3/30/2022 11:26 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 12:17:25 PM UTC-4, olcott
wrote:than a
On 3/30/2022 10:58 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 11:40:07 AM UTC-4, olcott
wrote:Like I said I will not tolerate endless strawman errors.
On 3/30/2022 8:13 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 8:59:34 AM UTC-4, olcottHb simulates <Ha^><Ha^>
wrote:Where N is the number of simulated steps required to >>>>>>>>>>>>>>>>>>>>>>>>> correctly match an
On 3/30/2022 7:06 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 12:02:48 AM UTC-4, >>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:H3a can correctly determine that <Infinite_Loop><> is
All that you are saying is that a halt determiner thatOn 3/29/2022 10:52 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, March 29, 2022 at 11:33:05 PM UTC-4, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
It is self evidently that the simulated input to >>>>>>>>>>>>>>>>>>>>>>>>>>>>> embedded_H cannotOn 3/29/2022 7:45 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, March 29, 2022 at 8:33:15 AM UTC-4,And by "distinctly different behavior" you mean >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "embedded_H simulated Ĥ applied to ⟨Ĥ⟩ incorrectly",
olcott wrote:assumed that ⟨Ĥ⟩ ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated outside of Ĥ must have the same behavior
The Linz proof only examines Ĥ applied to ⟨Ĥ⟩
thus embedded_H applied to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The key problem with this is that it is incorrectly
as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inside of Ĥ even after it is conclusively proved
that they have
distinctly different behavior >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
possibly reach its own final state of ⟨Ĥ.qn⟩ in any
finite number of
steps of correct simulation by embedded_H and you >>>>>>>>>>>>>>>>>>>>>>>>>>>>> know it.
And by the same logic, It is self evidentl that the
simulated input <N><5> to H3a cannot possibly reach
its own final state of <N.qy> in any finite number of
steps of correct simulation by H3a and you know it.
was intentionally
designed to get the wrong answer does get the wrong >>>>>>>>>>>>>>>>>>>>>>>>>>> answer. It is not
any rebuttal of my words at all and you know it. >>>>>>>>>>>>>>>>>>>>>>>>>>
non-halting, correct? So it's just a matter of >>>>>>>>>>>>>>>>>>>>>>>>>> determining how to find it it gets the right answer. >>>>>>>>>>>>>>>>>>>>>>>>>>
I will change my words so that your spec meets these
changed words:
It is self evidently correct that the simulated input
to h3a cannot
possibly reach its own final state of ⟨N.qy⟩ in any
insufficient number
number of steps of correct simulation by H3a. >>>>>>>>>>>>>>>>>>>>>>>>>>>
My specs says 1.. ∞ steps your spec says 1 .. 3 steps
embedded_Ha doesn't simulate <Ha^><Ha^> for infinite >>>>>>>>>>>>>>>>>>>>>>>>>> steps either. It simulates for up to some n number of
steps.
infinite behavior pattern such that the input is >>>>>>>>>>>>>>>>>>>>>>>>> correctly proved to
never reach its own final state or N is the number of >>>>>>>>>>>>>>>>>>>>>>>>> simulated steps
required for the input to reach its own final state. >>>>>>>>>>>>>>>>>>>>>>>>
Translation: "I will not tolerate any solid arguments that
conclusively prove I am wrong."
If Hb accepting <Ha^><Ha^> is wrong >>>>>>>>>>>>>>>>>>>>> It would be that it violated the specification thus no more
strawman error.
It does not violate the specification. The simulating halt >>>>>>>>>>>>>>>>>>>> decider Hb simulates enough steps of its input <Ha^><Ha^> to
correctly determine that its input reaches its final state of
<Ha^.qn> therefore it is correct to accept it. This means that
Ha and therefore embedded_Ha did *not* simulate enough steps
of <Ha^><Ha^> and gets the wrong answer. >>>>>>>>>>>>>>>>>>> THERE CANNOT POSSIBLY BE ANY CORRECT REBUTTAL TO THIS: >>>>>>>>>>>>>>>>>>> When embedded_H simulates enough steps of its input ⟨Ĥ⟩ ⟨Ĥ⟩ to
determine that this input cannot possibly reach its own final
state of
⟨Ĥ.qn⟩ then embedded_H would be correct to reject this input.
embedded_Ha does *not* simulate enough steps of its input >>>>>>>>>>>>>>>>>> <Ha^><Ha^> .
strawman error.
How does it violate the spec?
embedded_Ha IS REQUIRED TO SIMULATE ENOUGH STEPS OR IT VIOLATES THE
SPEC.
input never reaches its own final state or its simulated input reaches
its own final state.
Try and find an input that HHH does not decide correctly, everything
else is merely a deceitful attempt to get away with the strawman error.
Assuming HHH is Ha
We absolutely do not assume that.
We only assume that HHH has the proeperties shown above.
// NO INFINITE LOOP
// NO INFINITE LOOP
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy // NO INFINITE LOOP
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
state.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
final state.
Both embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ transition to their final reject
state as soon as they see an identical copy of embedded_H being >>>>>>>>>> simulated with identical input.
Recalling that the H above can also be referred to as Ha to denote a halt decider that aborts with the infinite simulation logic and Ha^ is built from Ha:
We can give the input <Ha^><Ha^> to Hb, which simulates for some k steps more than Ha,
Not k more than infinity, but k more than the n steps that Ha simulates.
And that is why I'm specifically using the name Ha to refer to the H that aborts. You're now talking about Hn which doesn't abort and *actually* can run for an infinite number of steps, but is unable to report on a non-halting input. Ha is only
It is ridiculously stupid to make breaking changes to a possibly correctIT IS ONLY THIS SINGLE POINT THAT CAUSES MY PROOF TO BE REJECTED:All of those permutations are moot. We don't need to look at any of them >>>> that get the wrong answer we only need to examine the one that gets the >>>> right answer and then see how Ĥ plugs in to this one.
So how exactly does Hb get the wrong answer for <Ha^><Ha^>?
HHH always simulates its input until it has complete proof that thisI'll tell you a secret: the Linz proof assumes that HHH exists and then proves that it gets the HHH^ case wrong, showing that it actually can't exist.
simulated input will never reach its final state or this simulated input >>>> reaches its final state.
If the template of HHH cannot be refuted then that makes it irrefutable. >>>
Linz and everyone here believes that deciders must base their decision
on non-finite string non-inputs Ĥ applied to ⟨Ĥ⟩ over-ruling the actual
behavior specified by the actual finite string actual input.
The definition of decider proves all of them wrong:
A decider maps its inputs to a final accept or reject state.
A halt decider maps its inputs to a final accept or reject state on the
basis of the actual behavior actually specified by its input.
The actual behavior actually specified by the input is measured by
whether or not the input could possibly reach its own final state when
correctly simulated by the simulating halt decider.
So let's apply that criteria to the turing machine N and the simulating halt deciders Ha3 and Ha7.
On Thursday, March 31, 2022 at 9:44:26 AM UTC-4, olcott wrote:able to simulate <Ha^><Ha^> for a finite number of steps (n), so Hb can simulate <Ha^><Ha^> for n+k steps and see it halt.
On 3/31/2022 6:51 AM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 11:13:25 PM UTC-4, olcott wrote:
On 3/30/2022 9:59 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 10:52:11 PM UTC-4, olcott wrote:
On 3/30/2022 9:40 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 10:35:50 PM UTC-4, olcott wrote: >>>>>>>> On 3/30/2022 9:16 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 10:05:32 PM UTC-4, olcott wrote: >>>>>>>>>> On 3/30/2022 8:59 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 7:35:26 PM UTC-4, olcott wrote: >>>>>>>>>>>> On 3/30/2022 4:01 PM, Dennis Bush wrote:and you just said that Ha simulates to infinity because Ha is merely >>>>>>>>>> another name for H. It is pretty ridiculously stupid to create a new >>>>>>>>>> name for identical behavior.
Not k more than infinity, but k more than the n steps that Ha simulates.On Wednesday, March 30, 2022 at 4:53:37 PM UTC-4, olcott wrote: >>>>>>>>>>>>>> On 3/30/2022 3:28 PM, olcott wrote:So great Hb simulates for some k steps more than infinity. >>>>>>>>>>>
On 3/30/2022 3:10 PM, Dennis Bush wrote:// NO INFINITE LOOP
On Wednesday, March 30, 2022 at 3:54:50 PM UTC-4, olcott wrote:
On 3/30/2022 12:37 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 1:29:19 PM UTC-4, olcott wrote:HHH always simulates its input until it has proof that its simulated
On 3/30/2022 12:20 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 1:12:48 PM UTC-4, olcott wrote:
embedded_H DOES SIMULATE ENOUGH STEPS.On 3/30/2022 12:10 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 1:03:43 PM UTC-4, olcott wrote:
Then it violates the spec and is merely a dishonest attempt at theOn 3/30/2022 11:53 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 12:40:04 PM UTC-4, olcott wrote:
correctlyOn 3/30/2022 11:26 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 12:17:25 PM UTC-4, olcott
wrote:than a
On 3/30/2022 10:58 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 11:40:07 AM UTC-4, olcott
wrote:
On 3/30/2022 8:13 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 8:59:34 AM UTC-4, olcott
wrote:Where N is the number of simulated steps required to
On 3/30/2022 7:06 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 12:02:48 AM UTC-4,
olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/29/2022 10:52 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, March 29, 2022 at 11:33:05 PM UTC-4,All that you are saying is that a halt determiner that
olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/29/2022 7:45 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, March 29, 2022 at 8:33:15 AM UTC-4,It is self evidently that the simulated input to
And by "distinctly different behavior" you meanolcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>assumed that ⟨Ĥ⟩ ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated outside of Ĥ must have the same behavior
The Linz proof only examines Ĥ applied to ⟨Ĥ⟩
thus embedded_H applied to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The key problem with this is that it is incorrectly
as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inside of Ĥ even after it is conclusively proved
that they have >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> distinctly different behavior >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"embedded_H simulated Ĥ applied to ⟨Ĥ⟩ incorrectly",
embedded_H cannot >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its own final state of ⟨Ĥ.qn⟩ in any
finite number of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps of correct simulation by embedded_H and you
know it.
And by the same logic, It is self evidentl that the
simulated input <N><5> to H3a cannot possibly reach
its own final state of <N.qy> in any finite number of
steps of correct simulation by H3a and you know it.
was intentionally >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> designed to get the wrong answer does get the wrong
answer. It is not >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any rebuttal of my words at all and you know it.
H3a can correctly determine that <Infinite_Loop><> is
non-halting, correct? So it's just a matter of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determining how to find it it gets the right answer.
I will change my words so that your spec meets these
changed words:
It is self evidently correct that the simulated input
to h3a cannot
possibly reach its own final state of ⟨N.qy⟩ in any
insufficient number >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> number of steps of correct simulation by H3a. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
My specs says 1.. ∞ steps your spec says 1 .. 3 steps
embedded_Ha doesn't simulate <Ha^><Ha^> for infinite
steps either. It simulates for up to some n number of
steps.
correctly match an
infinite behavior pattern such that the input is >>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly proved to
never reach its own final state or N is the number of
simulated steps
required for the input to reach its own final state.
Hb simulates <Ha^><Ha^> >>>>>>>>>>>>>>>>>>>>>>>>>>> Like I said I will not tolerate endless strawman errors.
Translation: "I will not tolerate any solid arguments that
conclusively prove I am wrong." >>>>>>>>>>>>>>>>>>>>>>>>>>
If Hb accepting <Ha^><Ha^> is wrong >>>>>>>>>>>>>>>>>>>>>>>>> It would be that it violated the specification thus no more
strawman error.
It does not violate the specification. The simulating halt
decider Hb simulates enough steps of its input <Ha^><Ha^> to
correctly determine that its input reaches its final state of
<Ha^.qn> therefore it is correct to accept it. This means that
Ha and therefore embedded_Ha did *not* simulate enough steps
of <Ha^><Ha^> and gets the wrong answer. >>>>>>>>>>>>>>>>>>>>>>> THERE CANNOT POSSIBLY BE ANY CORRECT REBUTTAL TO THIS: >>>>>>>>>>>>>>>>>>>>>>> When embedded_H simulates enough steps of its input ⟨Ĥ⟩ ⟨Ĥ⟩ to
determine that this input cannot possibly reach its own final
state of
⟨Ĥ.qn⟩ then embedded_H would be correct to reject this input.
embedded_Ha does *not* simulate enough steps of its input
<Ha^><Ha^> .
strawman error.
How does it violate the spec?
embedded_Ha IS REQUIRED TO SIMULATE ENOUGH STEPS OR IT VIOLATES THE
SPEC.
input never reaches its own final state or its simulated input reaches
its own final state.
Try and find an input that HHH does not decide correctly, everything
else is merely a deceitful attempt to get away with the strawman error.
Assuming HHH is Ha
We absolutely do not assume that.
We only assume that HHH has the proeperties shown above. >>>>>>>>>>>>>> // NO INFINITE LOOP
// NO INFINITE LOOP
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy // NO INFINITE LOOP
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
state.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
final state.
Both embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ transition to their final reject
state as soon as they see an identical copy of embedded_H being >>>>>>>>>>>>>> simulated with identical input.
Recalling that the H above can also be referred to as Ha to denote a halt decider that aborts with the infinite simulation logic and Ha^ is built from Ha:
We can give the input <Ha^><Ha^> to Hb, which simulates for some k steps more than Ha,
And that is why I'm specifically using the name Ha to refer to the H that aborts. You're now talking about Hn which doesn't abort and *actually* can run for an infinite number of steps, but is unable to report on a non-halting input. Ha is only
sequence of configurations.Testing to see how much one broken halt decider is broken.It is ridiculously stupid to make breaking changes to a possibly correct >>>> halt decider as the basis for determining whether or not this original >>>> halt decider is correct.IT IS ONLY THIS SINGLE POINT THAT CAUSES MY PROOF TO BE REJECTED:All of those permutations are moot. We don't need to look at any of them
that get the wrong answer we only need to examine the one that gets the
right answer and then see how Ĥ plugs in to this one.
So how exactly does Hb get the wrong answer for <Ha^><Ha^>?
HHH always simulates its input until it has complete proof that this >>>>>>>> simulated input will never reach its final state or this simulated input
reaches its final state.
If the template of HHH cannot be refuted then that makes it irrefutable.
I'll tell you a secret: the Linz proof assumes that HHH exists and then proves that it gets the HHH^ case wrong, showing that it actually can't exist.
Linz and everyone here believes that deciders must base their decision >>>>>> on non-finite string non-inputs Ĥ applied to ⟨Ĥ⟩ over-ruling the actual
behavior specified by the actual finite string actual input.
The definition of decider proves all of them wrong:
A decider maps its inputs to a final accept or reject state.
A halt decider maps its inputs to a final accept or reject state on the >>>>>> basis of the actual behavior actually specified by its input.
The actual behavior actually specified by the input is measured by >>>>>> whether or not the input could possibly reach its own final state when >>>>>> correctly simulated by the simulating halt decider.
So let's apply that criteria to the turing machine N and the simulating halt deciders Ha3 and Ha7.
All I did was use your definition of what a halt decider does and what the input to a halt decider specifies and applied it to a different set of halt deciders and inputs. The conclusions:
---
The behavior specified by the input <N><5> to Ha3 is measured by whether the input could possibly reach its own final state when correctly simulated by Ha3.
Since the correct pure simulation of 3 steps the input never reaches its final state of <N.qy>, Ha3 is correct to reject it.IT IS NOT CORRECT TO ACCEPT IT IS INCORRECT FOR IT TO BE INTENTIONALLY
BROKEN.
A broken halt decider that is broken too much for a specific input gets
the wrong answer.
Here is another similar example: int Sum(int N, int M) { return 5 };
Sum(3,5) ---> 5; // according to you 5 is the correct answer.
This does not contradict that N applied to <5> halts because it is a non-finite string non-input.
The input <N><5> to Ha7 does reach its final state of <N.qy> so Ha7 is correct to accept it. This does not contradict that the input <N><5> to Ha3 is rejected because the input to Ha3 is not the actual input to Ha7 and therefore specifies a different
to a halt decider is (as specified by Linz) M applied to <I>.---Same idea as using the above int Sum(int N, int M) { return 5 };
Sum(2,3)--->5
A broken halt decider that is not broken too much for a specific input
gets the right answer.
Are a direct consequence of these definitions. If you think the above is bogus, the only way for that to be possible is if your definition of "the actual behavior specified by the input" doesn't make sense, and that the behavior of the input <M><I>
The actual behavior actually specified by the input is measured by
whether or not the input could possibly reach its own final state
when correctly simulated by the simulating halt decider.
when correctly simulated by the simulating halt decider.
when correctly simulated by the simulating halt decider.
when correctly simulated by the simulating halt decider.
Incorrectly simulated by cutting off the simulation too soon does not count. >>> So either you stand by your definitions and accept the conclusion above that follows from it, or you accept that your alternate definition doesn't make sense and that neither Linz nor anyone else was "confused".
when correctly simulated by the simulating halt decider. Incorrectly
simulated by cutting off the simulation too soon does not count.
Your examples simply failed to meet the required spec thus are not valid
counter-examples at all.
So your criteria that a simulating halt decider is incorrect is that it cuts off the simulation too soon?
Then let's apply that to Ha.
Ha rejects <Ha^><Ha^>. But does it cut off its simulation too soon?
If Ha3 can be shown to be incorrect by giving the input to another halt decider that simulates for more steps, we can do the same for Ha.
We know that Ha will simulate for up to some number n of steps. So we create Hb that simulates for n+k steps. Hb accepts <Ha^><Ha^>.
Therefore we have shown that Ha does NOT do a correct simulation of <Ha^><Ha^> because it cuts of its simulation too soon, as demonstrated by Hb. The halting problem proof is therefore validated.
Q.E.D.
--
Copyright 2022 Pete Olcott
"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer
On 3/30/22 10:51 PM, olcott wrote:
On 3/30/2022 9:40 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 10:35:50 PM UTC-4, olcott wrote:
On 3/30/2022 9:16 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 10:05:32 PM UTC-4, olcott wrote:All of those permutations are moot. We don't need to look at any of
On 3/30/2022 8:59 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 7:35:26 PM UTC-4, olcott wrote: >>>>>>>> On 3/30/2022 4:01 PM, Dennis Bush wrote:and you just said that Ha simulates to infinity because Ha is merely >>>>>> another name for H. It is pretty ridiculously stupid to create a new >>>>>> name for identical behavior.
On Wednesday, March 30, 2022 at 4:53:37 PM UTC-4, olcott wrote: >>>>>>>>>> On 3/30/2022 3:28 PM, olcott wrote:So great Hb simulates for some k steps more than infinity.
On 3/30/2022 3:10 PM, Dennis Bush wrote:// NO INFINITE LOOP
On Wednesday, March 30, 2022 at 3:54:50 PM UTC-4, olcott wrote: >>>>>>>>>>>>> On 3/30/2022 12:37 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 1:29:19 PM UTC-4, olcott >>>>>>>>>>>>>> wrote:HHH always simulates its input until it has proof that its >>>>>>>>>>>>> simulated
On 3/30/2022 12:20 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 1:12:48 PM UTC-4, olcott >>>>>>>>>>>>>>>> wrote:embedded_H DOES SIMULATE ENOUGH STEPS.
On 3/30/2022 12:10 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 1:03:43 PM UTC-4, >>>>>>>>>>>>>>>>>> olcott wrote:Then it violates the spec and is merely a dishonest >>>>>>>>>>>>>>>>> attempt at the
On 3/30/2022 11:53 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 12:40:04 PM UTC-4, >>>>>>>>>>>>>>>>>>>> olcott wrote:
correctlyOn 3/30/2022 11:26 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 12:17:25 PM UTC-4, >>>>>>>>>>>>>>>>>>>>>> olcott
wrote:than a
On 3/30/2022 10:58 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 11:40:07 AM >>>>>>>>>>>>>>>>>>>>>>>> UTC-4, olcott
wrote:Like I said I will not tolerate endless strawman >>>>>>>>>>>>>>>>>>>>>>> errors.
On 3/30/2022 8:13 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 8:59:34 AM >>>>>>>>>>>>>>>>>>>>>>>>>> UTC-4, olcott
wrote:Where N is the number of simulated steps >>>>>>>>>>>>>>>>>>>>>>>>> required to
On 3/30/2022 7:06 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 12:02:48 AM >>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC-4,H3a can correctly determine that >>>>>>>>>>>>>>>>>>>>>>>>>> <Infinite_Loop><> is
olcott wrote:All that you are saying is that a halt >>>>>>>>>>>>>>>>>>>>>>>>>>> determiner that
On 3/29/2022 10:52 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, March 29, 2022 at 11:33:05 PM >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC-4,
olcott wrote:It is self evidently that the simulated >>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to
On 3/29/2022 7:45 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, March 29, 2022 at 8:33:15 AM >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC-4,And by "distinctly different behavior" you >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> mean
olcott wrote:assumed that ⟨Ĥ⟩ ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated outside of Ĥ must have the same >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior
The Linz proof only examines Ĥ applied >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to ⟨Ĥ⟩
thus embedded_H applied to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The key problem with this is that it is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrectly
as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inside of Ĥ even after it is conclusively >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proved
that they have
distinctly different behavior >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"embedded_H simulated Ĥ applied to ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrectly",
embedded_H cannot
possibly reach its own final state of >>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ.qn⟩ in any
finite number of
steps of correct simulation by embedded_H >>>>>>>>>>>>>>>>>>>>>>>>>>>>> and you
know it.
And by the same logic, It is self evidentl >>>>>>>>>>>>>>>>>>>>>>>>>>>> that the
simulated input <N><5> to H3a cannot >>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach
its own final state of <N.qy> in any finite >>>>>>>>>>>>>>>>>>>>>>>>>>>> number of
steps of correct simulation by H3a and you >>>>>>>>>>>>>>>>>>>>>>>>>>>> know it.
was intentionally
designed to get the wrong answer does get the >>>>>>>>>>>>>>>>>>>>>>>>>>> wrong
answer. It is not
any rebuttal of my words at all and you know it. >>>>>>>>>>>>>>>>>>>>>>>>>>
non-halting, correct? So it's just a matter of >>>>>>>>>>>>>>>>>>>>>>>>>> determining how to find it it gets the right >>>>>>>>>>>>>>>>>>>>>>>>>> answer.
I will change my words so that your spec >>>>>>>>>>>>>>>>>>>>>>>>>>> meets these
changed words:
It is self evidently correct that the >>>>>>>>>>>>>>>>>>>>>>>>>>> simulated input
to h3a cannot
possibly reach its own final state of ⟨N.qy⟩ >>>>>>>>>>>>>>>>>>>>>>>>>>> in any
insufficient number
number of steps of correct simulation by H3a. >>>>>>>>>>>>>>>>>>>>>>>>>>>
My specs says 1.. ∞ steps your spec says 1 .. >>>>>>>>>>>>>>>>>>>>>>>>>>> 3 steps
embedded_Ha doesn't simulate <Ha^><Ha^> for >>>>>>>>>>>>>>>>>>>>>>>>>> infinite
steps either. It simulates for up to some n >>>>>>>>>>>>>>>>>>>>>>>>>> number of
steps.
correctly match an
infinite behavior pattern such that the input is >>>>>>>>>>>>>>>>>>>>>>>>> correctly proved to
never reach its own final state or N is the >>>>>>>>>>>>>>>>>>>>>>>>> number of
simulated steps
required for the input to reach its own final >>>>>>>>>>>>>>>>>>>>>>>>> state.
Hb simulates <Ha^><Ha^>
Translation: "I will not tolerate any solid >>>>>>>>>>>>>>>>>>>>>> arguments that
conclusively prove I am wrong."
If Hb accepting <Ha^><Ha^> is wrong >>>>>>>>>>>>>>>>>>>>> It would be that it violated the specification thus >>>>>>>>>>>>>>>>>>>>> no more
strawman error.
It does not violate the specification. The >>>>>>>>>>>>>>>>>>>> simulating halt
decider Hb simulates enough steps of its input >>>>>>>>>>>>>>>>>>>> <Ha^><Ha^> to
correctly determine that its input reaches its final >>>>>>>>>>>>>>>>>>>> state of
<Ha^.qn> therefore it is correct to accept it. This >>>>>>>>>>>>>>>>>>>> means that
Ha and therefore embedded_Ha did *not* simulate >>>>>>>>>>>>>>>>>>>> enough steps
of <Ha^><Ha^> and gets the wrong answer. >>>>>>>>>>>>>>>>>>> THERE CANNOT POSSIBLY BE ANY CORRECT REBUTTAL TO THIS: >>>>>>>>>>>>>>>>>>> When embedded_H simulates enough steps of its input >>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ to
determine that this input cannot possibly reach its >>>>>>>>>>>>>>>>>>> own final
state of
⟨Ĥ.qn⟩ then embedded_H would be correct to reject >>>>>>>>>>>>>>>>>>> this input.
embedded_Ha does *not* simulate enough steps of its input >>>>>>>>>>>>>>>>>> <Ha^><Ha^> .
strawman error.
How does it violate the spec?
embedded_Ha IS REQUIRED TO SIMULATE ENOUGH STEPS OR IT >>>>>>>>>>>>>>> VIOLATES THE
SPEC.
input never reaches its own final state or its simulated >>>>>>>>>>>>> input reaches
its own final state.
Try and find an input that HHH does not decide correctly, >>>>>>>>>>>>> everything
else is merely a deceitful attempt to get away with the >>>>>>>>>>>>> strawman error.
Assuming HHH is Ha
We absolutely do not assume that.
We only assume that HHH has the proeperties shown above.
// NO INFINITE LOOP
// NO INFINITE LOOP
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy // NO INFINITE LOOP
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach
its final
state.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never
reach its
final state.
Both embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ transition to their
final reject
state as soon as they see an identical copy of embedded_H being >>>>>>>>>> simulated with identical input.
Recalling that the H above can also be referred to as Ha to
denote a halt decider that aborts with the infinite simulation >>>>>>>>> logic and Ha^ is built from Ha:
We can give the input <Ha^><Ha^> to Hb, which simulates for
some k steps more than Ha,
Not k more than infinity, but k more than the n steps that Ha
simulates.
And that is why I'm specifically using the name Ha to refer to the
H that aborts. You're now talking about Hn which doesn't abort and
*actually* can run for an infinite number of steps, but is unable
to report on a non-halting input. Ha is only able to simulate
<Ha^><Ha^> for a finite number of steps (n), so Hb can simulate
<Ha^><Ha^> for n+k steps and see it halt.
them
that get the wrong answer we only need to examine the one that gets the >>>> right answer and then see how Ĥ plugs in to this one.
So how exactly does Hb get the wrong answer for <Ha^><Ha^>?
HHH always simulates its input until it has complete proof that this
simulated input will never reach its final state or this simulated
input
reaches its final state.
If the template of HHH cannot be refuted then that makes it
irrefutable.
I'll tell you a secret: the Linz proof assumes that HHH exists and
then proves that it gets the HHH^ case wrong, showing that it
actually can't exist.
IT IS ONLY THIS SINGLE POINT THAT CAUSES MY PROOF TO BE REJECTED:
Linz and everyone here believes that deciders must base their decision
on non-finite string non-inputs Ĥ applied to ⟨Ĥ⟩ over-ruling the
actual behavior specified by the actual finite string actual input.
And actual behavior is define by H <M> w needs to answer on the behavior
of M applied to w.
On Wednesday, March 30, 2022 at 11:13:25 PM UTC-4, olcott wrote:able to simulate <Ha^><Ha^> for a finite number of steps (n), so Hb can simulate <Ha^><Ha^> for n+k steps and see it halt.
On 3/30/2022 9:59 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 10:52:11 PM UTC-4, olcott wrote:
On 3/30/2022 9:40 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 10:35:50 PM UTC-4, olcott wrote:
On 3/30/2022 9:16 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 10:05:32 PM UTC-4, olcott wrote: >>>>>>>> On 3/30/2022 8:59 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 7:35:26 PM UTC-4, olcott wrote: >>>>>>>>>> On 3/30/2022 4:01 PM, Dennis Bush wrote:and you just said that Ha simulates to infinity because Ha is merely >>>>>>>> another name for H. It is pretty ridiculously stupid to create a new >>>>>>>> name for identical behavior.
On Wednesday, March 30, 2022 at 4:53:37 PM UTC-4, olcott wrote: >>>>>>>>>>>> On 3/30/2022 3:28 PM, olcott wrote:So great Hb simulates for some k steps more than infinity.
On 3/30/2022 3:10 PM, Dennis Bush wrote:// NO INFINITE LOOP
On Wednesday, March 30, 2022 at 3:54:50 PM UTC-4, olcott wrote: >>>>>>>>>>>>>>> On 3/30/2022 12:37 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 1:29:19 PM UTC-4, olcott wrote:HHH always simulates its input until it has proof that its simulated
On 3/30/2022 12:20 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 1:12:48 PM UTC-4, olcott wrote:embedded_H DOES SIMULATE ENOUGH STEPS.
On 3/30/2022 12:10 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 1:03:43 PM UTC-4, olcott wrote:
Then it violates the spec and is merely a dishonest attempt at theOn 3/30/2022 11:53 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 12:40:04 PM UTC-4, olcott wrote:
correctlyOn 3/30/2022 11:26 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 12:17:25 PM UTC-4, olcott
wrote:than a
On 3/30/2022 10:58 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 11:40:07 AM UTC-4, olcott
wrote:Like I said I will not tolerate endless strawman errors.
On 3/30/2022 8:13 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 8:59:34 AM UTC-4, olcott
wrote:Where N is the number of simulated steps required to
On 3/30/2022 7:06 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 12:02:48 AM UTC-4,H3a can correctly determine that <Infinite_Loop><> is
olcott wrote:All that you are saying is that a halt determiner that
On 3/29/2022 10:52 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, March 29, 2022 at 11:33:05 PM UTC-4,
olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/29/2022 7:45 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, March 29, 2022 at 8:33:15 AM UTC-4,It is self evidently that the simulated input to
And by "distinctly different behavior" you meanolcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>assumed that ⟨Ĥ⟩ ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated outside of Ĥ must have the same behavior
The Linz proof only examines Ĥ applied to ⟨Ĥ⟩
thus embedded_H applied to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The key problem with this is that it is incorrectly
as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inside of Ĥ even after it is conclusively proved
that they have >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> distinctly different behavior >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"embedded_H simulated Ĥ applied to ⟨Ĥ⟩ incorrectly",
embedded_H cannot >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its own final state of ⟨Ĥ.qn⟩ in any
finite number of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps of correct simulation by embedded_H and you
know it.
And by the same logic, It is self evidentl that the
simulated input <N><5> to H3a cannot possibly reach
its own final state of <N.qy> in any finite number of
steps of correct simulation by H3a and you know it.
was intentionally
designed to get the wrong answer does get the wrong
answer. It is not
any rebuttal of my words at all and you know it. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
non-halting, correct? So it's just a matter of >>>>>>>>>>>>>>>>>>>>>>>>>>>> determining how to find it it gets the right answer.
I will change my words so that your spec meets these
changed words:
It is self evidently correct that the simulated input
to h3a cannot
possibly reach its own final state of ⟨N.qy⟩ in any
insufficient number
number of steps of correct simulation by H3a. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
My specs says 1.. ∞ steps your spec says 1 .. 3 steps
embedded_Ha doesn't simulate <Ha^><Ha^> for infinite
steps either. It simulates for up to some n number of
steps.
correctly match an
infinite behavior pattern such that the input is >>>>>>>>>>>>>>>>>>>>>>>>>>> correctly proved to
never reach its own final state or N is the number of
simulated steps
required for the input to reach its own final state.
Hb simulates <Ha^><Ha^>
Translation: "I will not tolerate any solid arguments that
conclusively prove I am wrong." >>>>>>>>>>>>>>>>>>>>>>>>
If Hb accepting <Ha^><Ha^> is wrong >>>>>>>>>>>>>>>>>>>>>>> It would be that it violated the specification thus no more
strawman error.
It does not violate the specification. The simulating halt
decider Hb simulates enough steps of its input <Ha^><Ha^> to
correctly determine that its input reaches its final state of
<Ha^.qn> therefore it is correct to accept it. This means that
Ha and therefore embedded_Ha did *not* simulate enough steps
of <Ha^><Ha^> and gets the wrong answer. >>>>>>>>>>>>>>>>>>>>> THERE CANNOT POSSIBLY BE ANY CORRECT REBUTTAL TO THIS: >>>>>>>>>>>>>>>>>>>>> When embedded_H simulates enough steps of its input ⟨Ĥ⟩ ⟨Ĥ⟩ to
determine that this input cannot possibly reach its own final
state of
⟨Ĥ.qn⟩ then embedded_H would be correct to reject this input.
embedded_Ha does *not* simulate enough steps of its input >>>>>>>>>>>>>>>>>>>> <Ha^><Ha^> .
strawman error.
How does it violate the spec?
embedded_Ha IS REQUIRED TO SIMULATE ENOUGH STEPS OR IT VIOLATES THE
SPEC.
input never reaches its own final state or its simulated input reaches
its own final state.
Try and find an input that HHH does not decide correctly, everything
else is merely a deceitful attempt to get away with the strawman error.
Assuming HHH is Ha
We absolutely do not assume that.
We only assume that HHH has the proeperties shown above. >>>>>>>>>>>> // NO INFINITE LOOP
// NO INFINITE LOOP
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy // NO INFINITE LOOP
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
state.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
final state.
Both embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ transition to their final reject
state as soon as they see an identical copy of embedded_H being >>>>>>>>>>>> simulated with identical input.
Recalling that the H above can also be referred to as Ha to denote a halt decider that aborts with the infinite simulation logic and Ha^ is built from Ha:
We can give the input <Ha^><Ha^> to Hb, which simulates for some k steps more than Ha,
Not k more than infinity, but k more than the n steps that Ha simulates.
And that is why I'm specifically using the name Ha to refer to the H that aborts. You're now talking about Hn which doesn't abort and *actually* can run for an infinite number of steps, but is unable to report on a non-halting input. Ha is only
It is ridiculously stupid to make breaking changes to a possibly correctIT IS ONLY THIS SINGLE POINT THAT CAUSES MY PROOF TO BE REJECTED:All of those permutations are moot. We don't need to look at any of them >>>>>> that get the wrong answer we only need to examine the one that gets the >>>>>> right answer and then see how Ĥ plugs in to this one.
So how exactly does Hb get the wrong answer for <Ha^><Ha^>?
HHH always simulates its input until it has complete proof that this >>>>>> simulated input will never reach its final state or this simulated input >>>>>> reaches its final state.I'll tell you a secret: the Linz proof assumes that HHH exists and then proves that it gets the HHH^ case wrong, showing that it actually can't exist.
If the template of HHH cannot be refuted then that makes it irrefutable. >>>>>
Linz and everyone here believes that deciders must base their decision >>>> on non-finite string non-inputs Ĥ applied to ⟨Ĥ⟩ over-ruling the actual
behavior specified by the actual finite string actual input.
The definition of decider proves all of them wrong:
A decider maps its inputs to a final accept or reject state.
A halt decider maps its inputs to a final accept or reject state on the >>>> basis of the actual behavior actually specified by its input.
The actual behavior actually specified by the input is measured by
whether or not the input could possibly reach its own final state when >>>> correctly simulated by the simulating halt decider.
So let's apply that criteria to the turing machine N and the simulating halt deciders Ha3 and Ha7.
halt decider as the basis for determining whether or not this original
halt decider is correct.
All I did was use your definition of what a halt decider does and what the input to a halt decider specifies and applied it to a different set of halt deciders and inputs. The conclusions:
---
The behavior specified by the input <N><5> to Ha3 is measured by whether the input could possibly reach its own final state when correctly simulated by Ha3.
Since the correct pure simulation of 3 steps the input never reaches its final state of <N.qy>, Ha3 is correct to reject it.
This does not contradict that N applied to <5> halts because it is a non-finite string non-input.sequence of configurations.
The input <N><5> to Ha7 does reach its final state of <N.qy> so Ha7 is correct to accept it. This does not contradict that the input <N><5> to Ha3 is rejected because the input to Ha3 is not the actual input to Ha7 and therefore specifies a different
---
Are a direct consequence of these definitions. If you think the above is bogus, the only way for that to be possible is if your definition of "the actual behavior specified by the input" doesn't make sense, and that the behavior of the input <M><I> toa halt decider is (as specified by Linz) M applied to <I>.
So either you stand by your definitions and accept the conclusion above that follows from it, or you accept that your alternate definition doesn't make sense and that neither Linz nor anyone else was "confused".
On Thursday, March 31, 2022 at 10:11:43 AM UTC-4, olcott wrote:only able to simulate <Ha^><Ha^> for a finite number of steps (n), so Hb can simulate <Ha^><Ha^> for n+k steps and see it halt.
On 3/31/2022 8:53 AM, Dennis Bush wrote:
On Thursday, March 31, 2022 at 9:44:26 AM UTC-4, olcott wrote:
On 3/31/2022 6:51 AM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 11:13:25 PM UTC-4, olcott wrote:
On 3/30/2022 9:59 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 10:52:11 PM UTC-4, olcott wrote: >>>>>>>> On 3/30/2022 9:40 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 10:35:50 PM UTC-4, olcott wrote: >>>>>>>>>> On 3/30/2022 9:16 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 10:05:32 PM UTC-4, olcott wrote: >>>>>>>>>>>> On 3/30/2022 8:59 PM, Dennis Bush wrote:
On Wednesday, March 30, 2022 at 7:35:26 PM UTC-4, olcott wrote: >>>>>>>>>>>>>> On 3/30/2022 4:01 PM, Dennis Bush wrote:and you just said that Ha simulates to infinity because Ha is merely
Not k more than infinity, but k more than the n steps that Ha simulates.On Wednesday, March 30, 2022 at 4:53:37 PM UTC-4, olcott wrote: >>>>>>>>>>>>>>>> On 3/30/2022 3:28 PM, olcott wrote:So great Hb simulates for some k steps more than infinity. >>>>>>>>>>>>>
On 3/30/2022 3:10 PM, Dennis Bush wrote:// NO INFINITE LOOP
On Wednesday, March 30, 2022 at 3:54:50 PM UTC-4, olcott wrote:
On 3/30/2022 12:37 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 1:29:19 PM UTC-4, olcott wrote:
HHH always simulates its input until it has proof that its simulatedOn 3/30/2022 12:20 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 1:12:48 PM UTC-4, olcott wrote:
embedded_H DOES SIMULATE ENOUGH STEPS. >>>>>>>>>>>>>>>>>>>>> embedded_Ha IS REQUIRED TO SIMULATE ENOUGH STEPS OR IT VIOLATES THEOn 3/30/2022 12:10 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 1:03:43 PM UTC-4, olcott wrote:
Then it violates the spec and is merely a dishonest attempt at theOn 3/30/2022 11:53 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 12:40:04 PM UTC-4, olcott wrote:
When embedded_H simulates enough steps of its input ⟨Ĥ⟩ ⟨Ĥ⟩ toOn 3/30/2022 11:26 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 12:17:25 PM UTC-4, olcott
wrote:than a
On 3/30/2022 10:58 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 11:40:07 AM UTC-4, olcott
wrote:
On 3/30/2022 8:13 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 8:59:34 AM UTC-4, olcott
wrote:Where N is the number of simulated steps required to
On 3/30/2022 7:06 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, March 30, 2022 at 12:02:48 AM UTC-4,
olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/29/2022 10:52 PM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, March 29, 2022 at 11:33:05 PM UTC-4,All that you are saying is that a halt determiner that
olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/29/2022 7:45 AM, Dennis Bush wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, March 29, 2022 at 8:33:15 AM UTC-4,It is self evidently that the simulated input to
And by "distinctly different behavior" you meanolcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>assumed that ⟨Ĥ⟩ ⟨Ĥ⟩ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated outside of Ĥ must have the same behavior
The Linz proof only examines Ĥ applied to ⟨Ĥ⟩
thus embedded_H applied to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The key problem with this is that it is incorrectly
as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> inside of Ĥ even after it is conclusively proved
that they have >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> distinctly different behavior >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
"embedded_H simulated Ĥ applied to ⟨Ĥ⟩ incorrectly",
embedded_H cannot >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its own final state of ⟨Ĥ.qn⟩ in any
finite number of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> steps of correct simulation by embedded_H and you
know it.
And by the same logic, It is self evidentl that the
simulated input <N><5> to H3a cannot possibly reach
its own final state of <N.qy> in any finite number of
steps of correct simulation by H3a and you know it.
was intentionally >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> designed to get the wrong answer does get the wrong
answer. It is not >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> any rebuttal of my words at all and you know it.
H3a can correctly determine that <Infinite_Loop><> is
non-halting, correct? So it's just a matter of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determining how to find it it gets the right answer.
I will change my words so that your spec meets these
changed words: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is self evidently correct that the simulated input
to h3a cannot >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly reach its own final state of ⟨N.qy⟩ in any
insufficient number >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> number of steps of correct simulation by H3a. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
My specs says 1.. ∞ steps your spec says 1 .. 3 steps
embedded_Ha doesn't simulate <Ha^><Ha^> for infinite
steps either. It simulates for up to some n number of
steps.
correctly match an >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite behavior pattern such that the input is
correctly proved to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never reach its own final state or N is the number of
simulated steps
required for the input to reach its own final state.
Hb simulates <Ha^><Ha^> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Like I said I will not tolerate endless strawman errors.
Translation: "I will not tolerate any solid arguments that
conclusively prove I am wrong." >>>>>>>>>>>>>>>>>>>>>>>>>>>>
If Hb accepting <Ha^><Ha^> is wrong >>>>>>>>>>>>>>>>>>>>>>>>>>> It would be that it violated the specification thus no more
strawman error.
It does not violate the specification. The simulating halt
decider Hb simulates enough steps of its input <Ha^><Ha^> to
correctly determine that its input reaches its final state of
<Ha^.qn> therefore it is correct to accept it. This means that
Ha and therefore embedded_Ha did *not* simulate enough steps
of <Ha^><Ha^> and gets the wrong answer. >>>>>>>>>>>>>>>>>>>>>>>>> THERE CANNOT POSSIBLY BE ANY CORRECT REBUTTAL TO THIS:
correctly
determine that this input cannot possibly reach its own final
state of
⟨Ĥ.qn⟩ then embedded_H would be correct to reject this input.
embedded_Ha does *not* simulate enough steps of its input
<Ha^><Ha^> .
strawman error.
How does it violate the spec?
SPEC.
input never reaches its own final state or its simulated input reaches
its own final state.
Try and find an input that HHH does not decide correctly, everything
else is merely a deceitful attempt to get away with the strawman error.
Assuming HHH is Ha
We absolutely do not assume that.
We only assume that HHH has the proeperties shown above. >>>>>>>>>>>>>>>> // NO INFINITE LOOP
// NO INFINITE LOOP
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy // NO INFINITE LOOP
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
state.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn >>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
final state.
Both embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ transition to their final reject
state as soon as they see an identical copy of embedded_H being
simulated with identical input.
Recalling that the H above can also be referred to as Ha to denote a halt decider that aborts with the infinite simulation logic and Ha^ is built from Ha:
We can give the input <Ha^><Ha^> to Hb, which simulates for some k steps more than Ha,
another name for H. It is pretty ridiculously stupid to create a new
name for identical behavior.
And that is why I'm specifically using the name Ha to refer to the H that aborts. You're now talking about Hn which doesn't abort and *actually* can run for an infinite number of steps, but is unable to report on a non-halting input. Ha is
different sequence of configurations.Testing to see how much one broken halt decider is broken.It is ridiculously stupid to make breaking changes to a possibly correct >>>>>> halt decider as the basis for determining whether or not this original >>>>>> halt decider is correct.IT IS ONLY THIS SINGLE POINT THAT CAUSES MY PROOF TO BE REJECTED: >>>>>>>>All of those permutations are moot. We don't need to look at any of them
that get the wrong answer we only need to examine the one that gets the
right answer and then see how Ĥ plugs in to this one.
So how exactly does Hb get the wrong answer for <Ha^><Ha^>?
HHH always simulates its input until it has complete proof that this >>>>>>>>>> simulated input will never reach its final state or this simulated input
reaches its final state.
If the template of HHH cannot be refuted then that makes it irrefutable.
I'll tell you a secret: the Linz proof assumes that HHH exists and then proves that it gets the HHH^ case wrong, showing that it actually can't exist.
Linz and everyone here believes that deciders must base their decision >>>>>>>> on non-finite string non-inputs Ĥ applied to ⟨Ĥ⟩ over-ruling the actual
behavior specified by the actual finite string actual input.
The definition of decider proves all of them wrong:
A decider maps its inputs to a final accept or reject state.
A halt decider maps its inputs to a final accept or reject state on the
basis of the actual behavior actually specified by its input.
The actual behavior actually specified by the input is measured by >>>>>>>> whether or not the input could possibly reach its own final state when >>>>>>>> correctly simulated by the simulating halt decider.
So let's apply that criteria to the turing machine N and the simulating halt deciders Ha3 and Ha7.
All I did was use your definition of what a halt decider does and what the input to a halt decider specifies and applied it to a different set of halt deciders and inputs. The conclusions:
---
The behavior specified by the input <N><5> to Ha3 is measured by whether the input could possibly reach its own final state when correctly simulated by Ha3.
Since the correct pure simulation of 3 steps the input never reaches its final state of <N.qy>, Ha3 is correct to reject it.IT IS NOT CORRECT TO ACCEPT IT IS INCORRECT FOR IT TO BE INTENTIONALLY >>>> BROKEN.
A broken halt decider that is broken too much for a specific input gets >>>> the wrong answer.
Here is another similar example: int Sum(int N, int M) { return 5 };
Sum(3,5) ---> 5; // according to you 5 is the correct answer.
This does not contradict that N applied to <5> halts because it is a non-finite string non-input.
The input <N><5> to Ha7 does reach its final state of <N.qy> so Ha7 is correct to accept it. This does not contradict that the input <N><5> to Ha3 is rejected because the input to Ha3 is not the actual input to Ha7 and therefore specifies a
to a halt decider is (as specified by Linz) M applied to <I>.---Same idea as using the above int Sum(int N, int M) { return 5 };
Sum(2,3)--->5
A broken halt decider that is not broken too much for a specific input >>>> gets the right answer.
Are a direct consequence of these definitions. If you think the above is bogus, the only way for that to be possible is if your definition of "the actual behavior specified by the input" doesn't make sense, and that the behavior of the input <M><I>
reject <Ha^><Ha^>.WTF? Do you agree that smashing you car's windshield with a sledgeThe actual behavior actually specified by the input is measured by
whether or not the input could possibly reach its own final state
when correctly simulated by the simulating halt decider.
when correctly simulated by the simulating halt decider.
when correctly simulated by the simulating halt decider.
when correctly simulated by the simulating halt decider.
Incorrectly simulated by cutting off the simulation too soon does not count.
So either you stand by your definitions and accept the conclusion above that follows from it, or you accept that your alternate definition doesn't make sense and that neither Linz nor anyone else was "confused".when correctly simulated by the simulating halt decider. Incorrectly
simulated by cutting off the simulation too soon does not count.
Your examples simply failed to meet the required spec thus are not valid >>>> counter-examples at all.
So your criteria that a simulating halt decider is incorrect is that it cuts off the simulation too soon?
Then let's apply that to Ha.
Ha rejects <Ha^><Ha^>. But does it cut off its simulation too soon?
hammer is not the proper way to start the engine of your car?
So that's all you're left with? Bad analogies?
Because of the way you've defined what the input to a halt decider represents and what a halt decider does, you have inconsistent logic.
Any logic you use to show that Ha is correct to reject <Ha^><Ha^> can also be used to show that Ha3 is correct to reject <N><5>, and any logic you use to show that Ha3 is not correct to reject <N><5> can be used to show that that Ha is not correct to
So it looks like you're stuck between a rock and a hard place.
If Ha3 can be shown to be incorrect by giving the input to another halt decider that simulates for more steps, we can do the same for Ha.No more bullshit examples please. They are nothing more than head games.
The fact that you think valid logic is a "bullshit example" or "head game" just shows how little logic you actually understand.
Bottom line: a halt decider H given input <M><I> is required to report if M applied to <I> halts.
Q.E.D.
On Thursday, March 31, 2022 at 10:48:09 AM UTC-4, olcott wrote:reject <Ha^><Ha^>.
On 3/31/2022 9:32 AM, Dennis Bush wrote:
On Thursday, March 31, 2022 at 10:11:43 AM UTC-4, olcott wrote:
Bottom line: a halt decider H given input <M><I> is required to report if M applied to <I> halts.The correct simulation of <M><I> by the simulating halt decider at the
point in the execution trace where the simulating halt decider actually
is does demonstrate the actual behavior specified by <M><I> at this
point in the execution trace.
It is merely a very persistent false assumption that a correct
simulation of <M><I> at some other different point in the execution
trace must derive identical behavior.
Using an alternate definition doesn't work as doing so leads to the above. >>>
Q.E.D.These three points are the basis of my correct analysis.
(1) Linz: computation that halts … the Turing machine will halt whenever >> it enters a final state. (Linz:1990:234)
The *turning machine*, not a partial simulation of a turing machine.
(2) That a correct simulation of a Turing machine description that would
never reach its final state is computationally equivalent to the direct
execution of this same Turing machine never reaching its final state.
The direct execution of the turing machine Ha^ applied to <Ha^> reaches a final state, therefore the correct simulation of that turing machine would reach a final state.
Hb applied to <Ha^><Ha^> reaches a final state of its input and is therefore a correct simulation. Ha applied to <Ha^><Ha^> does not reach a final state its input and is therefore not a correct simulation as demonstrated by Hb.
(3) That analyzing the behavior of a correct partial simulation of some
of the steps of a Turing machine description can accurately predict that
a full simulation would never reach its final state.
It *can*, but not in the case of Ha applied to <Ha^><Ha^> as demonstrated by Hb applied to <Ha^><Ha^>.
As I said before :
Any logic you use to show that Ha is correct to reject <Ha^><Ha^> can also be used to show that Ha3 is correct to reject <N><5>, and any logic you use to show that Ha3 is not correct to reject <N><5> can be used to show that that Ha is not correct to
olcott <NoOne@NoWhere.com> writes:DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR.
IT IS ONLY THIS SINGLE POINT THAT CAUSES MY PROOF TO BE REJECTED:
Linz and everyone here believes that deciders must base their decision
on non-finite string non-inputs Ĥ applied to ⟨Ĥ⟩ over-ruling the
actual behavior specified by the actual finite string actual input.
Here's that question you would not answer without equivocating, even
after my asking it more than 12 times in a row. André also asked many,
many times and got no answer.
What string must be passed to H so that H can tell us whether or not Ĥ applied to ⟨Ĥ⟩ halts? Do you reject even the idea that a halt decider could tell us whether a particular TM does or does not halt when given
some particular input? Isn't that what the theorem is about? (The
answer is, of course, yes.)
On 3/31/22 1:22 PM, olcott wrote:
On 3/31/2022 11:50 AM, Richard Damon wrote:
On 3/31/22 12:29 PM, olcott wrote:
On 3/31/2022 11:09 AM, Ben Bacarisse wrote:
olcott <NoOne@NoWhere.com> writes:DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR.
IT IS ONLY THIS SINGLE POINT THAT CAUSES MY PROOF TO BE REJECTED:Here's that question you would not answer without equivocating, even >>>>> after my asking it more than 12 times in a row. André also asked
Linz and everyone here believes that deciders must base their
decision
on non-finite string non-inputs Ĥ applied to ⟨Ĥ⟩ over-ruling the >>>>>> actual behavior specified by the actual finite string actual input. >>>>>
many,
many times and got no answer.
What string must be passed to H so that H can tell us whether or not Ĥ >>>>> applied to ⟨Ĥ⟩ halts? Do you reject even the idea that a halt decider
could tell us whether a particular TM does or does not halt when given >>>>> some particular input? Isn't that what the theorem is about? (The >>>>> answer is, of course, yes.)
The behavior of ⟨Ĥ⟩ ⟨Ĥ⟩ simulated outside of Ĥ must be
computationally equivalent to the direct execution of Ĥ applied to
⟨Ĥ⟩ yet not the same as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated inside of Ĥ. >>>>
DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR.
The directly executed Ĥ applied to ⟨Ĥ⟩ is the first invocation of >>>> infinite recursion that only terminates normally because of its
one-way dependency relationship on embedded_H aborting the second
invocation of this otherwise infinite recursion.
DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR.
UTM simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ at beginning
Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩
embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩
embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
UTM simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ at Ĥ.qx
embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩
embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
Nope, you made a BIG mistake
UTM simulatio of <H^> <H^> also begins with the H^ copies its input
<H^0> to <H^1>
Your second would be UTM simulation of <_embedded_H> <H^> <H^>
Which isn't the question.
You seem to forget that Turing Machine DO execute on their own.
Yes, embedded_H applied to <H^> <H^> is a different machine from H^
applied to <H^>, that is a given.
The PROBLEM you have is that embedded_H <H^> <H^> needs to answer
based on what H^ applied to <H^> will do, or equivalently what UTM
applied to <H^> <H^> will do, and that is ALWAYS the same and the
'outer' level of that is NEVER aborted, and if embedded_H goes to Qn,
the both of those will also go to H^.Qn and HALT< showing the ACTUAL
BEHAVIOR of the machine reprented by the input, and thus the CORRECT
answer, is HALTING.
If neither the outer level nor the inner level simulation aborts then
the simulation never stops.
Right. But the H / embedded_H fails to answer.
If either the outer level or the inner level must abort to prevent
infinite simulation then it correctly rejects its input.
THE OUTER LEVEL CAN'T abort, because it was defined to be a UTM, which
never aborts.
If the inner one aborts, because it is the simulating, the outer one
Halts, and shows the input to be HALTING and thus the decider to be
WRONG, and NOT correct.
FAIL.
If the outer level of simulation does not abort then this is
computationally equivalent to direct execution.
Right.
If the outer level of simulation does not abort and the inner level
does abort then the only reason that the outer level halts is that the
second invocation of an otherwise infinite recursion was aborted thus
terminating what would have otherwise been infinite recursion.
WRONG. Halting is Halting, It doesn't look at 'reason'.
FAIL.
On 3/31/22 12:29 PM, olcott wrote:
On 3/31/2022 11:09 AM, Ben Bacarisse wrote:
olcott <NoOne@NoWhere.com> writes:DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR.
IT IS ONLY THIS SINGLE POINT THAT CAUSES MY PROOF TO BE REJECTED:
Linz and everyone here believes that deciders must base their decision >>>> on non-finite string non-inputs Ĥ applied to ⟨Ĥ⟩ over-ruling the >>>> actual behavior specified by the actual finite string actual input.
Here's that question you would not answer without equivocating, even
after my asking it more than 12 times in a row. André also asked many, >>> many times and got no answer.
What string must be passed to H so that H can tell us whether or not Ĥ
applied to ⟨Ĥ⟩ halts? Do you reject even the idea that a halt decider
could tell us whether a particular TM does or does not halt when given
some particular input? Isn't that what the theorem is about? (The
answer is, of course, yes.)
The behavior of ⟨Ĥ⟩ ⟨Ĥ⟩ simulated outside of Ĥ must be computationally
equivalent to the direct execution of Ĥ applied to ⟨Ĥ⟩ yet not the
same as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated inside of Ĥ.
DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR.
The directly executed Ĥ applied to ⟨Ĥ⟩ is the first invocation of
infinite recursion that only terminates normally because of its
one-way dependency relationship on embedded_H aborting the second
invocation of this otherwise infinite recursion.
DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR.
UTM simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ at beginning
Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩
embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩
embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
UTM simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ at Ĥ.qx
embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩
embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
Nope, you made a BIG mistake
UTM simulatio of <H^> <H^> also begins with the H^ copies its input
<H^0> to <H^1>
Your second would be UTM simulation of <_embedded_H> <H^> <H^>
Which isn't the question.
You seem to forget that Turing Machine DO execute on their own.
Yes, embedded_H applied to <H^> <H^> is a different machine from H^
applied to <H^>, that is a given.
The PROBLEM you have is that embedded_H <H^> <H^> needs to answer based
on what H^ applied to <H^> will do, or equivalently what UTM applied to
<H^> <H^> will do, and that is ALWAYS the same and the 'outer' level of
that is NEVER aborted, and if embedded_H goes to Qn, the both of those
will also go to H^.Qn and HALT< showing the ACTUAL BEHAVIOR of the
machine reprented by the input, and thus the CORRECT answer, is HALTING.
On 3/31/22 1:57 PM, olcott wrote:
On 3/31/2022 12:45 PM, Richard Damon wrote:
On 3/31/22 1:22 PM, olcott wrote:
On 3/31/2022 11:50 AM, Richard Damon wrote:
On 3/31/22 12:29 PM, olcott wrote:
On 3/31/2022 11:09 AM, Ben Bacarisse wrote:
olcott <NoOne@NoWhere.com> writes:DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR. >>>>>>
IT IS ONLY THIS SINGLE POINT THAT CAUSES MY PROOF TO BE REJECTED: >>>>>>>>Here's that question you would not answer without equivocating, even >>>>>>> after my asking it more than 12 times in a row. André also asked >>>>>>> many,
Linz and everyone here believes that deciders must base their
decision
on non-finite string non-inputs Ĥ applied to ⟨Ĥ⟩ over-ruling the >>>>>>>> actual behavior specified by the actual finite string actual input. >>>>>>>
many times and got no answer.
What string must be passed to H so that H can tell us whether or >>>>>>> not Ĥ
applied to ⟨Ĥ⟩ halts? Do you reject even the idea that a halt >>>>>>> decider
could tell us whether a particular TM does or does not halt when >>>>>>> given
some particular input? Isn't that what the theorem is about? (The >>>>>>> answer is, of course, yes.)
The behavior of ⟨Ĥ⟩ ⟨Ĥ⟩ simulated outside of Ĥ must be
computationally equivalent to the direct execution of Ĥ applied to >>>>>> ⟨Ĥ⟩ yet not the same as ⟨Ĥ⟩ ⟨Ĥ⟩ simulated inside of Ĥ. >>>>>>
DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR. >>>>>>
The directly executed Ĥ applied to ⟨Ĥ⟩ is the first invocation of >>>>>> infinite recursion that only terminates normally because of its
one-way dependency relationship on embedded_H aborting the second
invocation of this otherwise infinite recursion.
DIFFERENT SEQUENCES OF CONFIGURATIONS WILL HAVE DIFFERENT BEHAVIOR. >>>>>>
UTM simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ at beginning
Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩
embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩
embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
UTM simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ at Ĥ.qx
embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩
embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
Nope, you made a BIG mistake
UTM simulatio of <H^> <H^> also begins with the H^ copies its input
<H^0> to <H^1>
Your second would be UTM simulation of <_embedded_H> <H^> <H^>
Which isn't the question.
You seem to forget that Turing Machine DO execute on their own.
Yes, embedded_H applied to <H^> <H^> is a different machine from H^
applied to <H^>, that is a given.
The PROBLEM you have is that embedded_H <H^> <H^> needs to answer
based on what H^ applied to <H^> will do, or equivalently what UTM
applied to <H^> <H^> will do, and that is ALWAYS the same and the
'outer' level of that is NEVER aborted, and if embedded_H goes to
Qn, the both of those will also go to H^.Qn and HALT< showing the
ACTUAL BEHAVIOR of the machine reprented by the input, and thus the
CORRECT answer, is HALTING.
If neither the outer level nor the inner level simulation aborts
then the simulation never stops.
Right. But the H / embedded_H fails to answer.
Right so that scenario must be rejected because the halt decider must
itself halt.
Not so much 'rejected' as shows that design of a Halt Decider doesn't work.
If either the outer level or the inner level must abort to prevent
infinite simulation then it correctly rejects its input.
THE OUTER LEVEL CAN'T abort, because it was defined to be a UTM,
which never aborts.
If the outer-level is stipulated to be a UTM then it cannot abort.
If the inner one aborts, because it is the simulating, the outer one
Halts, and shows the input to be HALTING and thus the decider to be
WRONG, and NOT correct.
These are the permutations that I am examining:
UTM UTM -> never halts
SHD UTM -> SHD correctly rejects
UTM SHD -> SHD correctly rejects
SHD SHD -> SHD correctly rejects
No, you are just babbling, they are NOT correct.
The ONLY case that actually matters is UTM SHD, as in UTM <H^> <H^>
which then inside the simulation of H^, we see the SHD of H.
The second item is NEVER a UTM, as you just agreed that H can't be just
a UTM (or if it is, it just proves the SHD that is a UTM fails). You
NEVER 'replace' the SHD with a UTM to look at the behavior of the input,
that is just an incorrect simulation.
Since UTM <H^> <H^> halts, the ONLY correct answer for SHD <H^> <H^> is halting (Qy) which is Not what it does.
FAIL
FAIL.
If the outer level of simulation does not abort then this is
computationally equivalent to direct execution.
Right.
If the outer level of simulation does not abort and the inner level
does abort then the only reason that the outer level halts is that
the second invocation of an otherwise infinite recursion was aborted
thus terminating what would have otherwise been infinite recursion.
WRONG. Halting is Halting, It doesn't look at 'reason'.
FAIL.
Sure it does. If there is conditional branch on one path and no
conditional branch on the other path then the behavior will vary
between paths.
You are just being silly.
You are talking about two copies of the exact same thing.
One can't have a condition the other doesn't have. That just shows you
are totally ignorant about what you are talking about.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 297 |
| Nodes: | 16 (0 / 16) |
| Uptime: | 120:34:32 |
| Calls: | 6,662 |
| Files: | 12,210 |
| Messages: | 5,334,424 |